twitter 4.8.1 → 5.0.0.rc.1

data/spec/twitter/saved_search_spec.rb

@@ -31,4 +31,15 @@ describe Twitter::SavedSearch do
     end
   end
 
+  describe "#created?" do
+    it "returns true when created_at is set" do
+      saved_search = Twitter::SavedSearch.new(:id => 16129012, :created_at => "Mon Jul 16 12:59:01 +0000 2007")
+      expect(saved_search.created?).to be_true
+    end
+    it "returns false when created_at is not set" do
+      saved_search = Twitter::SavedSearch.new(:id => 16129012)
+      expect(saved_search.created?).to be_false
+    end
+  end
+
 end

data/spec/twitter/search_results_spec.rb

@@ -2,15 +2,21 @@ require 'helper'
 
 describe Twitter::SearchResults do
 
-  describe "#statuses" do
-    it "returns an array of Tweets" do
-      statuses = Twitter::SearchResults.new(:statuses => [{:id => 25938088801, :text => 'tweet!'}]).statuses
-      expect(statuses).to be_an Array
-      expect(statuses.first).to be_a Twitter::Tweet
-    end
-    it "is empty when not set" do
-      statuses = Twitter::SearchResults.new.statuses
-      expect(statuses).to be_empty
+  describe "#each" do
+    before do
+      @search_results = Twitter::SearchResults.new(:statuses => [{:id => 1}, {:id => 2}, {:id => 3}, {:id => 4}, {:id => 5}, {:id => 6}])
+    end
+    it "iterates" do
+      count = 0
+      @search_results.each{count += 1}
+      expect(count).to eq(6)
+    end
+    context "with start" do
+      it "iterates" do
+        count = 0
+        @search_results.each(5){count += 1}
+        expect(count).to eq(1)
+      end
     end
   end
 
@@ -18,7 +24,7 @@ describe Twitter::SearchResults do
     it "returns a number of seconds" do
       completed_in = Twitter::SearchResults.new(:search_metadata => {:completed_in => 0.029}).completed_in
       expect(completed_in).to be_a Float
-      expect(completed_in).to eq 0.029
+      expect(completed_in).to eq(0.029)
     end
     it "is nil when not set" do
       completed_in = Twitter::SearchResults.new.completed_in
@@ -30,7 +36,7 @@ describe Twitter::SearchResults do
     it "returns an ID" do
       max_id = Twitter::SearchResults.new(:search_metadata => {:max_id => 250126199840518145}).max_id
       expect(max_id).to be_an Integer
-      expect(max_id).to eq 250126199840518145
+      expect(max_id).to eq(250126199840518145)
     end
     it "is nil when not set" do
       max_id = Twitter::SearchResults.new.max_id
@@ -42,7 +48,7 @@ describe Twitter::SearchResults do
     it "returns page number" do
       page = Twitter::SearchResults.new(:search_metadata => {:page => 1}).page
       expect(page).to be_an Integer
-      expect(page).to eq 1
+      expect(page).to eq(1)
     end
     it "is nil when not set" do
       page = Twitter::SearchResults.new.page
@@ -54,7 +60,7 @@ describe Twitter::SearchResults do
     it "returns the query" do
       query = Twitter::SearchResults.new(:search_metadata => {:query => "%23freebandnames"}).query
       expect(query).to be_a String
-      expect(query).to eq "%23freebandnames"
+      expect(query).to eq("%23freebandnames")
     end
     it "is nil when not set" do
       query = Twitter::SearchResults.new.query
@@ -64,9 +70,9 @@ describe Twitter::SearchResults do
 
   describe "#results_per_page" do
     it "returns the number of results per page" do
-      results_per_page = Twitter::SearchResults.new(:search_metadata => {:results_per_page => 4}).results_per_page
+      results_per_page = Twitter::SearchResults.new(:search_metadata => {:count => 4}).results_per_page
       expect(results_per_page).to be_an Integer
-      expect(results_per_page).to eq 4
+      expect(results_per_page).to eq(4)
     end
     it "is nil when not set" do
       results_per_page = Twitter::SearchResults.new.results_per_page
@@ -74,22 +80,11 @@ describe Twitter::SearchResults do
     end
   end
 
-  describe "#search_metadata?" do
-    it "returns true when search_metadata is set" do
-      search_metadata = Twitter::SearchResults.new(:search_metadata => {}).search_metadata?
-      expect(search_metadata).to be_true
-    end
-    it "returns false when search_metadata is not set" do
-      search_metadata = Twitter::SearchResults.new.search_metadata?
-      expect(search_metadata).to be_false
-    end
-  end
-
   describe "#since_id" do
     it "returns an ID" do
       since_id = Twitter::SearchResults.new(:search_metadata => {:since_id => 250126199840518145}).since_id
       expect(since_id).to be_an Integer
-      expect(since_id).to eq 250126199840518145
+      expect(since_id).to eq(250126199840518145)
     end
     it "is nil when not set" do
       since_id = Twitter::SearchResults.new.since_id
@@ -113,26 +108,18 @@ describe Twitter::SearchResults do
   end
 
   describe "#next_results" do
-    let(:next_results) {Twitter::SearchResults.new(:search_metadata => {:next_results => "?max_id=249279667666817023&q=%23freebandnames&count=4&include_entities=1&result_type=mixed"}).next_results}
-
     it "returns a hash of query parameters" do
-      expect(next_results).to be_a Hash
-    end
-
-    it "returns a max_id" do
-      expect(next_results[:max_id]).to eq "249279667666817023"
+      search_results = Twitter::SearchResults.new(:search_metadata => {:next_results => "?max_id=249279667666817023&q=%23freebandnames&count=4&include_entities=1&result_type=mixed"})
+      expect(search_results.next_results).to be_a Hash
+      expect(search_results.next_results[:max_id]).to eq("249279667666817023")
     end
   end
 
-  describe "#refresh_url" do
-    let(:refresh_url) {Twitter::SearchResults.new(:search_metadata => {:refresh_url => "?since_id=249279667666817023&q=%23freebandnames&count=4&include_entities=1&result_type=recent"}).refresh_url}
-
+  describe "#refresh_results" do
     it "returns a hash of query parameters" do
-      expect(refresh_url).to be_a Hash
-    end
-
-    it "returns a since_id" do
-      expect(refresh_url[:since_id]).to eq "249279667666817023"
+      search_results = Twitter::SearchResults.new(:search_metadata => {:refresh_url => "?since_id=249279667666817023&q=%23freebandnames&count=4&include_entities=1&result_type=recent"})
+      expect(search_results.refresh_results).to be_a Hash
+      expect(search_results.refresh_results[:since_id]).to eq("249279667666817023")
     end
   end
 

data/spec/twitter/settings_spec.rb

@@ -3,13 +3,24 @@ require 'helper'
 describe Twitter::Settings do
 
   describe "#trend_location" do
-    it "returns a Twitter::Place when set" do
-      place = Twitter::Settings.new(:trend_location => [{:countryCode => 'US', :name => 'San Francisco', :country => 'United States', :placeType => {:name => 'Town', :code => 7}, :woeid => 2487956, :parentid => 23424977, :url => 'http://where.yahooapis.com/v1/place/2487956'}])
-      expect(place.trend_location).to be_a Twitter::Place
+    it "returns a Twitter::Place when trend_location is set" do
+      settings = Twitter::Settings.new(:trend_location => {:countryCode => "US", :name => "San Francisco", :country => "United States", :placeType => {:name => "Town", :code => 7}, :woeid => 2487956, :parentid => 23424977, :url => "http://where.yahooapis.com/v1/place/2487956"})
+      expect(settings.trend_location).to be_a Twitter::Place
     end
-    it "returns nil when not set" do
-      place = Twitter::Settings.new
-      expect(place.trend_location).to be_nil
+    it "returns nil when trend_location is not set" do
+      settings = Twitter::Settings.new
+      expect(settings.trend_location).to be_nil
+    end
+  end
+
+  describe "#trend_location?" do
+    it "returns true when trend_location is set" do
+      settings = Twitter::Settings.new(:trend_location => {:countryCode => "US", :name => "San Francisco", :country => "United States", :placeType => {:name => "Town", :code => 7}, :woeid => 2487956, :parentid => 23424977, :url => "http://where.yahooapis.com/v1/place/2487956"})
+      expect(settings.trend_location?).to be_true
+    end
+    it "returns false when trend_location is not set" do
+      settings = Twitter::Settings.new
+      expect(settings.trend_location?).to be_false
     end
   end
 

data/spec/twitter/streaming/client_spec.rb

@@ -0,0 +1,75 @@
+require 'helper'
+
+describe Twitter::Streaming::Client do
+  before do
+    @client = Twitter::Streaming::Client.new
+  end
+
+  class FakeConnection
+    def initialize(body)
+      @body = body
+    end
+
+    def stream(request, response)
+      @body.each_line do |line|
+        response.on_body(line)
+      end
+    end
+  end
+
+  it "supports tracking keywords" do
+    @client.connection = FakeConnection.new(fixture("track_streaming.json"))
+    tweets = []
+    @client.filter(:track => "india") do |tweet|
+      tweets << tweet
+    end
+    expect(tweets).to have(2).entries
+    expect(tweets.first).to be_a Twitter::Tweet
+    expect(tweets.first.text).to eq "The problem with your code is that it's doing exactly what you told it to do."
+  end
+
+  it "supports firehose" do
+    @client.connection = FakeConnection.new(fixture("track_streaming.json"))
+    tweets = []
+    @client.firehose do |tweet|
+      tweets << tweet
+    end
+    expect(tweets).to have(2).entries
+    expect(tweets.first).to be_a Twitter::Tweet
+    expect(tweets.first.text).to eq "The problem with your code is that it's doing exactly what you told it to do."
+  end
+
+  it "supports sample" do
+    @client.connection = FakeConnection.new(fixture("track_streaming.json"))
+    tweets = []
+    @client.sample do |tweet|
+      tweets << tweet
+    end
+    expect(tweets).to have(2).entries
+    expect(tweets.first).to be_a Twitter::Tweet
+    expect(tweets.first.text).to eq "The problem with your code is that it's doing exactly what you told it to do."
+  end
+
+  it "supports site streams" do
+    @client.connection = FakeConnection.new(fixture("track_streaming.json"))
+    tweets = []
+    @client.site(7505382) do |tweet|
+      tweets << tweet
+    end
+    expect(tweets).to have(2).entries
+    expect(tweets.first).to be_a Twitter::Tweet
+    expect(tweets.first.text).to eq "The problem with your code is that it's doing exactly what you told it to do."
+  end
+
+  it "supports user streams" do
+    @client.connection = FakeConnection.new(fixture("track_streaming.json"))
+    tweets = []
+    @client.user do |tweet|
+      tweets << tweet
+    end
+    expect(tweets).to have(2).entries
+    expect(tweets.first).to be_a Twitter::Tweet
+    expect(tweets.first.text).to eq "The problem with your code is that it's doing exactly what you told it to do."
+  end
+
+end

data/spec/twitter/token_spec.rb

@@ -0,0 +1,16 @@
+require 'helper'
+
+describe Twitter::Token do
+
+  describe "#bearer?" do
+    it "returns true when token is a bearer token" do
+      token = Twitter::Token.new(:token_type => "bearer")
+      expect(token.bearer?).to be_true
+    end
+    it "returns false when token type is nil" do
+      token = Twitter::Token.new
+      expect(token.bearer?).to be_false
+    end
+  end
+
+end

data/spec/twitter/trend_results_spec.rb

@@ -0,0 +1,89 @@
+require 'helper'
+
+describe Twitter::TrendResults do
+
+  describe "#as_of" do
+    it "returns a Time when as_of is set" do
+      trend_results = Twitter::TrendResults.new(:id => 1, :as_of => "2012-08-24T23:25:43Z")
+      expect(trend_results.as_of).to be_a Time
+    end
+    it "returns nil when as_of is not set" do
+      trend_results = Twitter::TrendResults.new(:id => 1)
+      expect(trend_results.as_of).to be_nil
+    end
+  end
+
+  describe "#as_of?" do
+    it "returns true when as_of is set" do
+      trend_results = Twitter::TrendResults.new(:id => 1, :as_of => "2012-08-24T23:24:14Z")
+      expect(trend_results.as_of?).to be_true
+    end
+    it "returns false when as_of is not set" do
+      trend_results = Twitter::TrendResults.new(:id => 1)
+      expect(trend_results.as_of?).to be_false
+    end
+  end
+
+  describe "#created_at" do
+    it "returns a Time when created_at is set" do
+      trend_results = Twitter::TrendResults.new(:id => 1, :created_at => "2012-08-24T23:24:14Z")
+      expect(trend_results.created_at).to be_a Time
+    end
+    it "returns nil when created_at is not set" do
+      trend_results = Twitter::TrendResults.new(:id => 1)
+      expect(trend_results.created_at).to be_nil
+    end
+  end
+
+  describe "#created?" do
+    it "returns true when created_at is set" do
+      trend_results = Twitter::TrendResults.new(:id => 1, :created_at => "2012-08-24T23:24:14Z")
+      expect(trend_results.created?).to be_true
+    end
+    it "returns false when created_at is not set" do
+      trend_results = Twitter::TrendResults.new(:id => 1)
+      expect(trend_results.created?).to be_false
+    end
+  end
+
+  describe "#each" do
+    before do
+      @trend_results = Twitter::TrendResults.new(:trends => [{:id => 1}, {:id => 2}, {:id => 3}, {:id => 4}, {:id => 5}, {:id => 6}])
+    end
+    it "iterates" do
+      count = 0
+      @trend_results.each{count += 1}
+      expect(count).to eq(6)
+    end
+    context "with start" do
+      it "iterates" do
+        count = 0
+        @trend_results.each(5){count += 1}
+        expect(count).to eq(1)
+      end
+    end
+  end
+
+  describe "#location" do
+    it "returns a Twitter::Place when location is set" do
+      trend_results = Twitter::TrendResults.new(:id => 1, :locations => [{:name => "Worldwide", :woeid => 1}])
+      expect(trend_results.location).to be_a Twitter::Place
+    end
+    it "returns nil when location is not set" do
+      trend_results = Twitter::TrendResults.new(:id => 1)
+      expect(trend_results.location).to be_nil
+    end
+  end
+
+  describe "#location?" do
+    it "returns true when location is set" do
+      trend_results = Twitter::TrendResults.new(:id => 1, :locations => [{:name => "Worldwide", :woeid => 1}])
+      expect(trend_results.location?).to be_true
+    end
+    it "returns false when location is not set" do
+      trend_results = Twitter::TrendResults.new(:id => 1)
+      expect(trend_results.location?).to be_false
+    end
+  end
+
+end

data/spec/twitter/trend_spec.rb

@@ -35,4 +35,27 @@ describe Twitter::Trend do
     end
   end
 
+  describe "#uri" do
+    it "returns a URI when the url is set" do
+      trend = Twitter::Trend.new(:url => "http://twitter.com/search/?q=%23sevenwordsaftersex")
+      expect(trend.uri).to be_a URI
+      expect(trend.uri.to_s).to eq("http://twitter.com/search/?q=%23sevenwordsaftersex")
+    end
+    it "returns nil when the url is not set" do
+      trend = Twitter::Trend.new
+      expect(trend.uri).to be_nil
+    end
+  end
+
+  describe "#uri?" do
+    it "returns true when the url is set" do
+      trend = Twitter::Trend.new(:url => "https://api.twitter.com/1.1/geo/id/247f43d441defc03.json")
+      expect(trend.uri?).to be_true
+    end
+    it "returns false when the url is not set" do
+      trend = Twitter::Trend.new
+      expect(trend.uri?).to be_false
+    end
+  end
+
 end

data/spec/twitter/tweet_spec.rb

@@ -40,6 +40,17 @@ describe Twitter::Tweet do
     end
   end
 
+  describe "#created?" do
+    it "returns true when created_at is set" do
+      tweet = Twitter::Tweet.new(:id => 28669546014, :created_at => "Mon Jul 16 12:59:01 +0000 2007")
+      expect(tweet.created?).to be_true
+    end
+    it "returns false when created_at is not set" do
+      tweet = Twitter::Tweet.new(:id => 28669546014)
+      expect(tweet.created?).to be_false
+    end
+  end
+
   describe "#entities?" do
     it "returns false if there are no entities set" do
       tweet = Twitter::Tweet.new(:id => 28669546014)
@@ -49,9 +60,9 @@ describe Twitter::Tweet do
     it "returns true if there are entities set" do
       urls_array = [
         {
-          :url => 'http://example.com/t.co',
-          :expanded_url => 'http://example.com/expanded',
-          :display_url => 'example.com/expanded',
+          :url => "http://example.com/t.co",
+          :expanded_url => "http://example.com/expanded",
+          :display_url => "example.com/expanded",
           :indices => [10, 33],
         }
       ]
@@ -60,62 +71,33 @@ describe Twitter::Tweet do
     end
   end
 
-  describe "#favoriters_count" do
-    it "returns the count of favoriters when favoriters_count is set" do
-      tweet = Twitter::Tweet.new(:id => 28669546014, :favoriters_count => '1')
-      expect(tweet.favoriters_count).to be_an Integer
-      expect(tweet.favoriters_count).to eq 1
-    end
-    it "returns nil when not set" do
-      tweet = Twitter::Tweet.new(:id => 28669546014)
-      expect(tweet.favoriters_count).to be_nil
-    end
-  end
-
-  describe "#from_user" do
-    it "returns a screen name when from_user is set" do
-      tweet = Twitter::Tweet.new(:id => 28669546014, :from_user => 'sferik')
-      expect(tweet.from_user).to be_a String
-      expect(tweet.from_user).to eq "sferik"
-    end
-    it "returns a screen name when screen_name is set" do
-      tweet = Twitter::Tweet.new(:id => 28669546014, :user => {:id => 7505382, :screen_name => 'sferik'})
-      expect(tweet.from_user).to be_a String
-      expect(tweet.from_user).to eq "sferik"
-    end
-    it "returns nil when not set" do
-      tweet = Twitter::Tweet.new(:id => 28669546014)
-      expect(tweet.from_user).to be_nil
-    end
-  end
-
   describe "#filter_level" do
     it "returns the filter level when filter_level is set" do
-      tweet = Twitter::Tweet.new(:id => 28669546014, :filter_level => 'high')
+      tweet = Twitter::Tweet.new(:id => 28669546014, :filter_level => "high")
       expect(tweet.filter_level).to be_a String
-      expect(tweet.filter_level).to eq "high"
+      expect(tweet.filter_level).to eq("high")
     end
     it "returns \"none\" when not set" do
       tweet = Twitter::Tweet.new(:id => 28669546014)
-      expect(tweet.filter_level).to eq "none"
+      expect(tweet.filter_level).to eq("none")
     end
   end
 
   describe "#full_text" do
     it "returns the text of a Tweet" do
-      tweet = Twitter::Tweet.new(:id => 28669546014, :text => 'BOOSH')
+      tweet = Twitter::Tweet.new(:id => 28669546014, :text => "BOOSH")
       expect(tweet.full_text).to be_a String
-      expect(tweet.full_text).to eq "BOOSH"
+      expect(tweet.full_text).to eq("BOOSH")
     end
     it "returns the text of a Tweet without a user" do
-      tweet = Twitter::Tweet.new(:id => 28669546014, :text => 'BOOSH', :retweeted_status => {:id => 28561922517, :text => 'BOOSH'})
+      tweet = Twitter::Tweet.new(:id => 28669546014, :text => "BOOSH", :retweeted_status => {:id => 28561922517, :text => "BOOSH"})
       expect(tweet.full_text).to be_a String
-      expect(tweet.full_text).to eq "BOOSH"
+      expect(tweet.full_text).to eq("BOOSH")
     end
     it "returns the full text of a retweeted Tweet" do
-      tweet = Twitter::Tweet.new(:id => 28669546014, :text => 'RT @sferik: BOOSH', :retweeted_status => {:id => 28561922516, :text => 'BOOSH'})
+      tweet = Twitter::Tweet.new(:id => 28669546014, :text => "RT @sferik: BOOSH", :retweeted_status => {:id => 25938088801, :text => "BOOSH"})
       expect(tweet.full_text).to be_a String
-      expect(tweet.full_text).to eq "RT @sferik: BOOSH"
+      expect(tweet.full_text).to eq("RT @sferik: BOOSH")
     end
     it "returns nil when retweeted_status is not set" do
       tweet = Twitter::Tweet.new(:id => 28669546014)
@@ -124,29 +106,40 @@ describe Twitter::Tweet do
   end
 
   describe "#geo" do
-    it "returns a Twitter::Geo::Point when set" do
-      tweet = Twitter::Tweet.new(:id => 28669546014, :geo => {:id => 1, :type => 'Point'})
+    it "returns a Twitter::Geo::Point when geo is set" do
+      tweet = Twitter::Tweet.new(:id => 28669546014, :geo => {:id => 1, :type => "Point"})
       expect(tweet.geo).to be_a Twitter::Geo::Point
     end
-    it "returns nil when not set" do
+    it "returns nil when geo is not set" do
       tweet = Twitter::Tweet.new(:id => 28669546014)
       expect(tweet.geo).to be_nil
     end
   end
 
+  describe "#geo?" do
+    it "returns true when geo is set" do
+      tweet = Twitter::Tweet.new(:id => 28669546014, :geo => {:id => 1, :type => "Point"})
+      expect(tweet.geo?).to be_true
+    end
+    it "returns false when geo is not set" do
+      tweet = Twitter::Tweet.new(:id => 28669546014)
+      expect(tweet.geo?).to be_false
+    end
+  end
+
   describe "#hashtags" do
-    it "returns an Array of Entity::Hashtag when entities are set" do
+    it "returns an array of Entity::Hashtag when entities are set" do
       hashtags_array = [
         {
-          :text => 'twitter',
+          :text => "twitter",
           :indices => [10, 33],
         }
       ]
       hashtags = Twitter::Tweet.new(:id => 28669546014, :entities => {:hashtags => hashtags_array}).hashtags
       expect(hashtags).to be_an Array
       expect(hashtags.first).to be_a Twitter::Entity::Hashtag
-      expect(hashtags.first.indices).to eq [10, 33]
-      expect(hashtags.first.text).to eq 'twitter'
+      expect(hashtags.first.indices).to eq([10, 33])
+      expect(hashtags.first.text).to eq("twitter")
     end
     it "is empty when not set" do
       hashtags = Twitter::Tweet.new(:id => 28669546014).hashtags
@@ -160,7 +153,7 @@ describe Twitter::Tweet do
 
   describe "#media" do
     it "returns media" do
-      media = Twitter::Tweet.new(:id => 28669546014, :entities => {:media => [{:id => 1, :type => 'photo'}]}).media
+      media = Twitter::Tweet.new(:id => 28669546014, :entities => {:media => [{:id => 1, :type => "photo"}]}).media
       expect(media).to be_an Array
       expect(media.first).to be_a Twitter::Media::Photo
     end
@@ -175,36 +168,46 @@ describe Twitter::Tweet do
   end
 
   describe "#metadata" do
-    it "returns a User when user is set" do
-      metadata = Twitter::Tweet.new(:id => 28669546014, :metadata => {}).metadata
-      expect(metadata).to be_a Twitter::Metadata
+    it "returns a Twitter::Metadata when metadata is set" do
+      tweet = Twitter::Tweet.new(:id => 28669546014, :metadata => {})
+      expect(tweet.metadata).to be_a Twitter::Metadata
     end
-    it "returns nil when user is not set" do
-      metadata = Twitter::Tweet.new(:id => 28669546014).metadata
-      expect(metadata).to be_nil
+    it "returns nil when metadata is not set" do
+      tweet = Twitter::Tweet.new(:id => 28669546014)
+      expect(tweet.metadata).to be_nil
+    end
+  end
+
+  describe "#metadata?" do
+    it "returns true when metadata is set" do
+      tweet = Twitter::Tweet.new(:id => 28669546014, :metadata => {})
+      expect(tweet.metadata?).to be_true
+    end
+    it "returns false when metadata is not set" do
+      tweet = Twitter::Tweet.new(:id => 28669546014)
+      expect(tweet.metadata?).to be_false
     end
   end
 
   describe "#place" do
-    it "returns a Twitter::Place when set" do
+    it "returns a Twitter::Place when place is set" do
       tweet = Twitter::Tweet.new(:id => 28669546014, :place => {:id => "247f43d441defc03"})
       expect(tweet.place).to be_a Twitter::Place
     end
-    it "returns nil when not set" do
+    it "returns nil when place is not set" do
       tweet = Twitter::Tweet.new(:id => 28669546014)
       expect(tweet.place).to be_nil
     end
   end
 
-  describe "#repliers_count" do
-    it "returns the count of favoriters when repliers_count is set" do
-      tweet = Twitter::Tweet.new(:id => 28669546014, :repliers_count => '1')
-      expect(tweet.repliers_count).to be_an Integer
-      expect(tweet.repliers_count).to eq 1
+  describe "#place?" do
+    it "returns true when place is set" do
+      tweet = Twitter::Tweet.new(:id => 28669546014, :place => {:id => "247f43d441defc03"})
+      expect(tweet.place?).to be_true
     end
-    it "returns nil when not set" do
+    it "returns false when place is not set" do
       tweet = Twitter::Tweet.new(:id => 28669546014)
-      expect(tweet.repliers_count).to be_nil
+      expect(tweet.place?).to be_false
     end
   end
 
@@ -221,7 +224,7 @@ describe Twitter::Tweet do
 
   describe "#retweet?" do
     it "returns true when there is a retweeted status" do
-      tweet = Twitter::Tweet.new(:id => 28669546014, :retweeted_status => {:id => 28561922516, :text => 'BOOSH'})
+      tweet = Twitter::Tweet.new(:id => 28669546014, :retweeted_status => {:id => 25938088801, :text => "BOOSH"})
       expect(tweet.retweet?).to be_true
     end
     it "returns false when retweeted_status is not set" do
@@ -231,10 +234,10 @@ describe Twitter::Tweet do
   end
 
   describe "#retweeted_status" do
-    it "has text when retweeted_status is set" do
-      tweet = Twitter::Tweet.new(:id => 28669546014, :retweeted_status => {:id => 28561922516, :text => 'BOOSH'})
+    it "returns a Tweet when retweeted_status is set" do
+      tweet = Twitter::Tweet.new(:id => 28669546014, :retweeted_status => {:id => 25938088801, :text => "BOOSH"})
       expect(tweet.retweeted_tweet).to be_a Twitter::Tweet
-      expect(tweet.retweeted_tweet.text).to eq 'BOOSH'
+      expect(tweet.retweeted_tweet.text).to eq("BOOSH")
     end
     it "returns nil when retweeted_status is not set" do
       tweet = Twitter::Tweet.new(:id => 28669546014)
@@ -242,35 +245,29 @@ describe Twitter::Tweet do
     end
   end
 
-  describe "#retweeters_count" do
-    it "returns the count of favoriters when retweet_count is set" do
-      tweet = Twitter::Tweet.new(:id => 28669546014, :retweet_count => '1')
-      expect(tweet.retweeters_count).to be_an Integer
-      expect(tweet.retweeters_count).to eq 1
-    end
-    it "returns the count of favoriters when retweeters_count is set" do
-      tweet = Twitter::Tweet.new(:id => 28669546014, :retweeters_count => '1')
-      expect(tweet.retweeters_count).to be_an Integer
-      expect(tweet.retweeters_count).to eq 1
+  describe "#retweeted_status?" do
+    it "returns true when retweeted_status is set" do
+      tweet = Twitter::Tweet.new(:id => 28669546014, :retweeted_status => {:id => 25938088801, :text => "BOOSH"})
+      expect(tweet.retweeted_status?).to be_true
     end
-    it "returns nil when not set" do
+    it "returns false when retweeted_status is not set" do
       tweet = Twitter::Tweet.new(:id => 28669546014)
-      expect(tweet.retweeters_count).to be_nil
+      expect(tweet.retweeted_status?).to be_false
     end
   end
 
   describe "#symbols" do
-    it "returns an Array of Entity::Symbol when symbols are set" do
+    it "returns an array of Entity::Symbol when symbols are set" do
       symbols_array = [
-        { :text => 'PEP', :indices => [114, 118] },
-        { :text => 'COKE', :indices => [128, 133] }
+        { :text => "PEP", :indices => [114, 118] },
+        { :text => "COKE", :indices => [128, 133] }
       ]
       symbols = Twitter::Tweet.new(:id => 28669546014, :entities => {:symbols => symbols_array}).symbols
       expect(symbols).to be_an Array
-      expect(symbols.size).to eq 2
+      expect(symbols.size).to eq(2)
       expect(symbols.first).to be_a Twitter::Entity::Symbol
-      expect(symbols.first.indices).to eq [114, 118]
-      expect(symbols.first.text).to eq 'PEP'
+      expect(symbols.first.indices).to eq([114, 118])
+      expect(symbols.first.text).to eq("PEP")
     end
     it "is empty when not set" do
       symbols = Twitter::Tweet.new(:id => 28669546014).symbols
@@ -282,25 +279,26 @@ describe Twitter::Tweet do
     end
   end
 
-  describe "#urls" do
-    it "returns an Array of Entity::Url when entities are set" do
+  describe "#uris" do
+    it "returns an array of Entity::URIs when entities are set" do
       urls_array = [
         {
-          :url => 'http://example.com/t.co',
-          :expanded_url => 'http://example.com/expanded',
-          :display_url => 'example.com/expanded',
+          :url => "http://example.com/t.co",
+          :expanded_url => "http://example.com/expanded",
+          :display_url => "example.com/expanded",
           :indices => [10, 33],
         }
       ]
-      urls = Twitter::Tweet.new(:id => 28669546014, :entities => {:urls => urls_array}).urls
-      expect(urls).to be_an Array
-      expect(urls.first).to be_a Twitter::Entity::Url
-      expect(urls.first.indices).to eq [10, 33]
-      expect(urls.first.display_url).to eq 'example.com/expanded'
+      tweet = Twitter::Tweet.new(:id => 28669546014, :entities => {:urls => urls_array})
+      expect(tweet.uris).to be_an Array
+      expect(tweet.uris.first).to be_a Twitter::Entity::URI
+      expect(tweet.uris.first.indices).to eq([10, 33])
+      expect(tweet.uris.first.display_uri).to be_a URI
+      expect(tweet.uris.first.display_uri.to_s).to eq("example.com/expanded")
     end
     it "is empty when not set" do
-      urls = Twitter::Tweet.new(:id => 28669546014).urls
-      expect(urls).to be_empty
+      tweet = Twitter::Tweet.new(:id => 28669546014)
+      expect(tweet.uris).to be_empty
     end
     it "warns when not set" do
       Twitter::Tweet.new(:id => 28669546014).urls
@@ -308,39 +306,48 @@ describe Twitter::Tweet do
     end
   end
 
+  describe "#uri" do
+    it "returns the URI to the tweet" do
+      tweet = Twitter::Tweet.new(:id => 28669546014, :user => {:id => 7505382, :screen_name => "sferik"})
+      expect(tweet.uri).to be_a URI
+      expect(tweet.uri.to_s).to eq("https://twitter.com/sferik/status/28669546014")
+    end
+  end
+
   describe "#user" do
     it "returns a User when user is set" do
-      user = Twitter::Tweet.new(:id => 28669546014, :user => {:id => 7505382}).user
-      expect(user).to be_a Twitter::User
+      tweet = Twitter::Tweet.new(:id => 28669546014, :user => {:id => 7505382})
+      expect(tweet.user).to be_a Twitter::User
     end
     it "returns nil when user is not set" do
-      user = Twitter::Tweet.new(:id => 28669546014).user
-      expect(user).to be_nil
+      tweet = Twitter::Tweet.new(:id => 28669546014)
+      expect(tweet.user).to be_nil
     end
-    it "has a status when status is set" do
-      user = Twitter::Tweet.new(:id => 28669546014, :text => 'Tweet text.', :user => {:id => 7505382}).user
-      expect(user.status).to be_a Twitter::Tweet
+    it "has a status is set" do
+      tweet = Twitter::Tweet.new(:id => 28669546014, :text => "Tweet text.", :user => {:id => 7505382})
+      expect(tweet.user.status).to be_a Twitter::Tweet
+      expect(tweet.user.status.id).to eq 28669546014
     end
   end
 
   describe "#user?" do
     it "returns true when status is set" do
-      user = Twitter::Tweet.new(:id => 28669546014, :user => {:id => 7505382}).user?
-      expect(user).to be_true
+      tweet = Twitter::Tweet.new(:id => 28669546014, :user => {:id => 7505382})
+      expect(tweet.user?).to be_true
     end
     it "returns false when status is not set" do
-      user = Twitter::Tweet.new(:id => 28669546014).user?
-      expect(user).to be_false
+      tweet = Twitter::Tweet.new(:id => 28669546014)
+      expect(tweet.user?).to be_false
     end
   end
 
   describe "#user_mentions" do
-    it "returns an Array of Entity::UserMention when entities are set" do
+    it "returns an array of Entity::UserMention when entities are set" do
       user_mentions_array = [
         {
-          :screen_name => 'sferik',
-          :name => 'Erik Michaels-Ober',
-          :id_str => '7505382',
+          :screen_name => "sferik",
+          :name => "Erik Michaels-Ober",
+          :id_str => "7505382",
           :indices => [0, 6],
           :id => 7505382,
         }
@@ -348,8 +355,8 @@ describe Twitter::Tweet do
       user_mentions = Twitter::Tweet.new(:id => 28669546014, :entities => {:user_mentions => user_mentions_array}).user_mentions
       expect(user_mentions).to be_an Array
       expect(user_mentions.first).to be_a Twitter::Entity::UserMention
-      expect(user_mentions.first.indices).to eq [0, 6]
-      expect(user_mentions.first.id).to eq 7505382
+      expect(user_mentions.first.indices).to eq([0, 6])
+      expect(user_mentions.first.id).to eq(7505382)
     end
     it "is empty when not set" do
       user_mentions = Twitter::Tweet.new(:id => 28669546014).user_mentions