twitter 4.1.0 → 4.1.1

data/spec/twitter/place_spec.rb

@@ -6,69 +6,69 @@ describe Twitter::Place do
     it "returns true when objects IDs are the same" do
       place = Twitter::Place.new(:id => 1, :name => "foo")
       other = Twitter::Place.new(:id => 1, :name => "bar")
-      (place == other).should be_true
+      expect(place == other).to be_true
     end
     it "returns false when objects IDs are different" do
       place = Twitter::Place.new(:id => 1)
       other = Twitter::Place.new(:id => 2)
-      (place == other).should be_false
+      expect(place == other).to be_false
     end
     it "returns false when classes are different" do
       place = Twitter::Place.new(:id => 1)
       other = Twitter::Identity.new(:id => 1)
-      (place == other).should be_false
+      expect(place == other).to be_false
     end
   end
 
   describe "#bounding_box" do
     it "returns a Twitter::Place when set" do
       place = Twitter::Place.new(:id => "247f43d441defc03", :bounding_box => {:type => 'Polygon', :coordinates => [[[-122.40348192, 37.77752898], [-122.387436, 37.77752898], [-122.387436, 37.79448597], [-122.40348192, 37.79448597]]]})
-      place.bounding_box.should be_a Twitter::Geo::Polygon
+      expect(place.bounding_box).to be_a Twitter::Geo::Polygon
     end
     it "returns nil when not set" do
       place = Twitter::Place.new(:id => "247f43d441defc03")
-      place.bounding_box.should be_nil
+      expect(place.bounding_box).to be_nil
     end
   end
 
   describe "#country_code" do
     it "returns a country code when set with country_code" do
       place = Twitter::Place.new(:id => "247f43d441defc03", :country_code => 'US')
-      place.country_code.should eq 'US'
+      expect(place.country_code).to eq 'US'
     end
     it "returns a country code when set with countryCode" do
       place = Twitter::Place.new(:id => "247f43d441defc03", :countryCode => 'US')
-      place.country_code.should eq 'US'
+      expect(place.country_code).to eq 'US'
     end
     it "returns nil when not set" do
       place = Twitter::Place.new(:id => "247f43d441defc03")
-      place.country_code.should be_nil
+      expect(place.country_code).to be_nil
     end
   end
 
   describe "#parent_id" do
     it "returns a parent ID when set with parentid" do
       place = Twitter::Place.new(:id => "247f43d441defc03", :parentid => 1)
-      place.parent_id.should eq 1
+      expect(place.parent_id).to eq 1
     end
     it "returns nil when not set" do
       place = Twitter::Place.new(:id => "247f43d441defc03")
-      place.parent_id.should be_nil
+      expect(place.parent_id).to be_nil
     end
   end
 
   describe "#place_type" do
     it "returns a place type when set with place_type" do
       place = Twitter::Place.new(:id => "247f43d441defc03", :place_type => 'city')
-      place.place_type.should eq 'city'
+      expect(place.place_type).to eq 'city'
     end
     it "returns a place type when set with placeType[name]" do
       place = Twitter::Place.new(:id => "247f43d441defc03", :placeType => {:name => 'Town'})
-      place.place_type.should eq 'Town'
+      expect(place.place_type).to eq 'Town'
     end
     it "returns nil when not set" do
       place = Twitter::Place.new(:id => "247f43d441defc03")
-      place.place_type.should be_nil
+      expect(place.place_type).to be_nil
     end
   end
 

data/spec/twitter/rate_limit_spec.rb

@@ -5,36 +5,36 @@ describe Twitter::RateLimit do
   describe "#limit" do
     it "returns an Integer when x-rate-limit-limit header is set" do
       rate_limit = Twitter::RateLimit.new('x-rate-limit-limit' => "150")
-      rate_limit.limit.should be_an Integer
-      rate_limit.limit.should eq 150
+      expect(rate_limit.limit).to be_an Integer
+      expect(rate_limit.limit).to eq 150
     end
     it "returns nil when x-rate-limit-limit header is not set" do
       rate_limit = Twitter::RateLimit.new
-      rate_limit.limit.should be_nil
+      expect(rate_limit.limit).to be_nil
     end
   end
 
   describe "#remaining" do
     it "returns an Integer when x-rate-limit-remaining header is set" do
       rate_limit = Twitter::RateLimit.new('x-rate-limit-remaining' => "149")
-      rate_limit.remaining.should be_an Integer
-      rate_limit.remaining.should eq 149
+      expect(rate_limit.remaining).to be_an Integer
+      expect(rate_limit.remaining).to eq 149
     end
     it "returns nil when x-rate-limit-remaining header is not set" do
       rate_limit = Twitter::RateLimit.new
-      rate_limit.remaining.should be_nil
+      expect(rate_limit.remaining).to be_nil
     end
   end
 
   describe "#reset_at" do
     it "returns a Time when x-rate-limit-reset header is set" do
       rate_limit = Twitter::RateLimit.new('x-rate-limit-reset' => "1339019097")
-      rate_limit.reset_at.should be_a Time
-      rate_limit.reset_at.should eq Time.at(1339019097)
+      expect(rate_limit.reset_at).to be_a Time
+      expect(rate_limit.reset_at).to eq Time.at(1339019097)
     end
     it "returns nil when x-rate-limit-reset header is not set" do
       rate_limit = Twitter::RateLimit.new
-      rate_limit.reset_at.should be_nil
+      expect(rate_limit.reset_at).to be_nil
     end
   end
 
@@ -47,12 +47,12 @@ describe Twitter::RateLimit do
     end
     it "returns an Integer when x-rate-limit-reset header is set" do
       rate_limit = Twitter::RateLimit.new('x-rate-limit-reset' => "1339019097")
-      rate_limit.reset_in.should be_an Integer
-      rate_limit.reset_in.should eq 15777
+      expect(rate_limit.reset_in).to be_an Integer
+      expect(rate_limit.reset_in).to eq 15777
     end
     it "returns nil when x-rate-limit-reset header is not set" do
       rate_limit = Twitter::RateLimit.new
-      rate_limit.reset_in.should be_nil
+      expect(rate_limit.reset_in).to be_nil
     end
   end
 
@@ -65,11 +65,11 @@ describe Twitter::RateLimit do
     end
     it "updates a rate limit" do
       rate_limit = Twitter::RateLimit.new('x-rate-limit-reset' => "1339019097")
-      rate_limit.reset_in.should be_an Integer
-      rate_limit.reset_in.should eq 15777
+      expect(rate_limit.reset_in).to be_an Integer
+      expect(rate_limit.reset_in).to eq 15777
       rate_limit.update({'x-rate-limit-reset' => "1339019098"})
-      rate_limit.reset_in.should be_an Integer
-      rate_limit.reset_in.should eq 15778
+      expect(rate_limit.reset_in).to be_an Integer
+      expect(rate_limit.reset_in).to eq 15778
     end
   end
 

data/spec/twitter/relationship_spec.rb

@@ -5,22 +5,22 @@ describe Twitter::Relationship do
   describe "#source" do
     it "returns a User when source is set" do
       source = Twitter::Relationship.new(:relationship => {:source => {:id => 7505382}}).source
-      source.should be_a Twitter::SourceUser
+      expect(source).to be_a Twitter::SourceUser
     end
     it "returns nil when source is not set" do
       source = Twitter::Relationship.new(:relationship => {}).source
-      source.should be_nil
+      expect(source).to be_nil
     end
   end
 
   describe "#target" do
     it "returns a User when target is set" do
       target = Twitter::Relationship.new(:relationship => {:target => {:id => 7505382}}).target
-      target.should be_a Twitter::TargetUser
+      expect(target).to be_a Twitter::TargetUser
     end
     it "returns nil when target is not set" do
       target = Twitter::Relationship.new(:relationship => {}).target
-      target.should be_nil
+      expect(target).to be_nil
     end
   end
 
@@ -28,7 +28,7 @@ describe Twitter::Relationship do
     it "updates a relationship" do
       relationship = Twitter::Relationship.new(:relationship => {:target => {:id => 7505382}})
       relationship.update(:relationship => {:target => {:id => 14100886}})
-      relationship.target.id.should eq 14100886
+      expect(relationship.target.id).to eq 14100886
     end
   end
 

data/spec/twitter/saved_search_spec.rb

@@ -6,28 +6,28 @@ describe Twitter::SavedSearch do
     it "returns true when objects IDs are the same" do
       saved_search = Twitter::SavedSearch.new(:id => 1, :name => "foo")
       other = Twitter::SavedSearch.new(:id => 1, :name => "bar")
-      (saved_search == other).should be_true
+      expect(saved_search == other).to be_true
     end
     it "returns false when objects IDs are different" do
       saved_search = Twitter::SavedSearch.new(:id => 1)
       other = Twitter::SavedSearch.new(:id => 2)
-      (saved_search == other).should be_false
+      expect(saved_search == other).to be_false
     end
     it "returns false when classes are different" do
       saved_search = Twitter::SavedSearch.new(:id => 1)
       other = Twitter::Identity.new(:id => 1)
-      (saved_search == other).should be_false
+      expect(saved_search == other).to be_false
     end
   end
 
   describe "#created_at" do
     it "returns a Time when created_at is set" do
       saved_search = Twitter::SavedSearch.new(:id => 16129012, :created_at => "Mon Jul 16 12:59:01 +0000 2007")
-      saved_search.created_at.should be_a Time
+      expect(saved_search.created_at).to be_a Time
     end
     it "returns nil when created_at is not set" do
       saved_search = Twitter::SavedSearch.new(:id => 16129012)
-      saved_search.created_at.should be_nil
+      expect(saved_search.created_at).to be_nil
     end
   end
 

data/spec/twitter/search_results_spec.rb

@@ -5,84 +5,84 @@ describe Twitter::SearchResults do
   describe "#statuses" do
     it "returns an array of Tweets" do
       statuses = Twitter::SearchResults.new(:statuses => [{:id => 25938088801, :text => 'tweet!'}]).statuses
-      statuses.should be_an Array
-      statuses.first.should be_a Twitter::Tweet
+      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
-      statuses.should be_empty
+      expect(statuses).to be_empty
     end
   end
 
   describe "#completed_in" do
     it "returns a number of seconds" do
       completed_in = Twitter::SearchResults.new(:search_metadata => {:completed_in => 0.029}).completed_in
-      completed_in.should be_a Float
-      completed_in.should eq 0.029
+      expect(completed_in).to be_a Float
+      expect(completed_in).to eq 0.029
     end
     it "is nil when not set" do
       completed_in = Twitter::SearchResults.new.completed_in
-      completed_in.should be_nil
+      expect(completed_in).to be_nil
     end
   end
 
   describe "#max_id" do
     it "returns an ID" do
       max_id = Twitter::SearchResults.new(:search_metadata => {:max_id => 250126199840518145}).max_id
-      max_id.should be_an Integer
-      max_id.should eq 250126199840518145
+      expect(max_id).to be_an Integer
+      expect(max_id).to eq 250126199840518145
     end
     it "is nil when not set" do
       max_id = Twitter::SearchResults.new.max_id
-      max_id.should be_nil
+      expect(max_id).to be_nil
     end
   end
 
   describe "#page" do
     it "returns page number" do
       page = Twitter::SearchResults.new(:search_metadata => {:page => 1}).page
-      page.should be_an Integer
-      page.should eq 1
+      expect(page).to be_an Integer
+      expect(page).to eq 1
     end
     it "is nil when not set" do
       page = Twitter::SearchResults.new.page
-      page.should be_nil
+      expect(page).to be_nil
     end
   end
 
   describe "#query" do
     it "returns the query" do
       query = Twitter::SearchResults.new(:search_metadata => {:query => "%23freebandnames"}).query
-      query.should be_a String
-      query.should eq "%23freebandnames"
+      expect(query).to be_a String
+      expect(query).to eq "%23freebandnames"
     end
     it "is nil when not set" do
       query = Twitter::SearchResults.new.query
-      query.should be_nil
+      expect(query).to be_nil
     end
   end
 
   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.should be_an Integer
-      results_per_page.should eq 4
+      expect(results_per_page).to be_an Integer
+      expect(results_per_page).to eq 4
     end
     it "is nil when not set" do
       results_per_page = Twitter::SearchResults.new.results_per_page
-      results_per_page.should be_nil
+      expect(results_per_page).to be_nil
     end
   end
 
   describe "#since_id" do
     it "returns an ID" do
       since_id = Twitter::SearchResults.new(:search_metadata => {:since_id => 250126199840518145}).since_id
-      since_id.should be_an Integer
-      since_id.should eq 250126199840518145
+      expect(since_id).to be_an Integer
+      expect(since_id).to eq 250126199840518145
     end
     it "is nil when not set" do
       since_id = Twitter::SearchResults.new.since_id
-      since_id.should be_nil
+      expect(since_id).to be_nil
     end
   end
 

data/spec/twitter/settings_spec.rb

@@ -5,11 +5,11 @@ 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'}])
-      place.trend_location.should be_a Twitter::Place
+      expect(place.trend_location).to be_a Twitter::Place
     end
     it "returns nil when not set" do
       place = Twitter::Settings.new
-      place.trend_location.should be_nil
+      expect(place.trend_location).to be_nil
     end
   end
 

data/spec/twitter/size_spec.rb

@@ -6,32 +6,32 @@ describe Twitter::Size do
     it "returns false for empty objects" do
       size = Twitter::Size.new
       other = Twitter::Size.new
-      (size == other).should be_false
+      expect(size == other).to be_false
     end
     it "returns true when objects height and width are the same" do
       size = Twitter::Size.new(:h => 1, :w => 1, :resize => true)
       other = Twitter::Size.new(:h => 1, :w => 1, :resize => false)
-      (size == other).should be_true
+      expect(size == other).to be_true
     end
     it "returns false when objects height or width are different" do
       size = Twitter::Size.new(:h => 1, :w => 1)
       other = Twitter::Size.new(:h => 1, :w => 2)
-      (size == other).should be_false
+      expect(size == other).to be_false
     end
     it "returns false when classes are different" do
       size = Twitter::Size.new(:h => 1, :w => 1)
       other = Twitter::Base.new(:h => 1, :w => 1)
-      (size == other).should be_false
+      expect(size == other).to be_false
     end
     it "returns true when objects non-height and width attributes are the same" do
       size = Twitter::Size.new(:resize => true)
       other = Twitter::Size.new(:resize => true)
-      (size == other).should be_true
+      expect(size == other).to be_true
     end
     it "returns false when objects non-height and width attributes are different" do
       size = Twitter::Size.new(:resize => true)
       other = Twitter::Size.new(:resize => false)
-      (size == other).should be_false
+      expect(size == other).to be_false
     end
   end
 

data/spec/twitter/source_user_spec.rb

@@ -6,17 +6,17 @@ describe Twitter::SourceUser do
     it "returns true when objects IDs are the same" do
       saved_search = Twitter::SourceUser.new(:id => 1, :name => "foo")
       other = Twitter::SourceUser.new(:id => 1, :name => "bar")
-      (saved_search == other).should be_true
+      expect(saved_search == other).to be_true
     end
     it "returns false when objects IDs are different" do
       saved_search = Twitter::SourceUser.new(:id => 1)
       other = Twitter::SourceUser.new(:id => 2)
-      (saved_search == other).should be_false
+      expect(saved_search == other).to be_false
     end
     it "returns false when classes are different" do
       saved_search = Twitter::SourceUser.new(:id => 1)
       other = Twitter::Identity.new(:id => 1)
-      (saved_search == other).should be_false
+      expect(saved_search == other).to be_false
     end
   end
 

data/spec/twitter/suggestion_spec.rb

@@ -6,44 +6,44 @@ describe Twitter::Suggestion do
     it "returns false for empty objects" do
       suggestion = Twitter::Suggestion.new
       other = Twitter::Suggestion.new
-      (suggestion == other).should be_false
+      expect(suggestion == other).to be_false
     end
     it "returns true when objects slugs are the same" do
       suggestion = Twitter::Suggestion.new(:slug => 1, :name => "foo")
       other = Twitter::Suggestion.new(:slug => 1, :name => "bar")
-      (suggestion == other).should be_true
+      expect(suggestion == other).to be_true
     end
     it "returns false when objects slugs are different" do
       suggestion = Twitter::Suggestion.new(:slug => 1)
       other = Twitter::Suggestion.new(:slug => 2)
-      (suggestion == other).should be_false
+      expect(suggestion == other).to be_false
     end
     it "returns false when classes are different" do
       suggestion = Twitter::Suggestion.new(:slug => 1)
       other = Twitter::Base.new(:slug => 1)
-      (suggestion == other).should be_false
+      expect(suggestion == other).to be_false
     end
     it "returns true when objects non-slug attributes are the same" do
       suggestion = Twitter::Suggestion.new(:name => "foo")
       other = Twitter::Suggestion.new(:name => "foo")
-      (suggestion == other).should be_true
+      expect(suggestion == other).to be_true
     end
     it "returns false when objects non-slug attributes are different" do
       suggestion = Twitter::Suggestion.new(:name => "foo")
       other = Twitter::Suggestion.new(:name => "bar")
-      (suggestion == other).should be_false
+      expect(suggestion == other).to be_false
     end
   end
 
   describe "#users" do
     it "returns a User when user is set" do
       users = Twitter::Suggestion.new(:users => [{:id => 7505382}]).users
-      users.should be_an Array
-      users.first.should be_a Twitter::User
+      expect(users).to be_an Array
+      expect(users.first).to be_a Twitter::User
     end
     it "is empty when not set" do
       users = Twitter::Suggestion.new.users
-      users.should be_empty
+      expect(users).to be_empty
     end
   end