twitter 5.1.1 → 5.2.0

data/spec/twitter/rest/client_spec.rb

@@ -3,191 +3,187 @@ require 'helper'
 describe Twitter::REST::Client do
 
   before do
-    @client = Twitter::REST::Client.new(:consumer_key => "CK", :consumer_secret => "CS", :access_token => "AT", :access_token_secret => "AS")
+    @client = Twitter::REST::Client.new(:consumer_key => 'CK', :consumer_secret => 'CS', :access_token => 'AT', :access_token_secret => 'AS')
   end
 
-  describe ".new" do
-    context "when invalid credentials are provided" do
-      it "raises a ConfigurationError exception" do
-        expect {
-          Twitter::REST::Client.new(:consumer_key => [12345, 54321])
-        }.to raise_exception(Twitter::Error::ConfigurationError)
+  describe '.new' do
+    context 'when invalid credentials are provided' do
+      it 'raises a ConfigurationError exception' do
+        expect { Twitter::REST::Client.new(:consumer_key => [12_345, 54_321]) }.to raise_exception(Twitter::Error::ConfigurationError)
       end
     end
 
-    context "when no credentials are provided" do
-      it "does not raise an exception" do
-        expect {
-          Twitter::REST::Client.new
-        }.not_to raise_error
+    context 'when no credentials are provided' do
+      it 'does not raise an exception' do
+        expect { Twitter::REST::Client.new }.not_to raise_error
       end
     end
   end
 
-  describe ".credentials?" do
-    it "returns true if only bearer_token is supplied" do
-      client = Twitter::REST::Client.new(:bearer_token => "BT")
+  describe '.credentials?' do
+    it 'returns true if only bearer_token is supplied' do
+      client = Twitter::REST::Client.new(:bearer_token => 'BT')
       expect(client.credentials?).to be true
     end
-    it "returns true if all OAuth credentials are present" do
-      client = Twitter::REST::Client.new(:consumer_key => "CK", :consumer_secret => "CS", :access_token => "AT", :access_token_secret => "AS")
+    it 'returns true if all OAuth credentials are present' do
+      client = Twitter::REST::Client.new(:consumer_key => 'CK', :consumer_secret => 'CS', :access_token => 'AT', :access_token_secret => 'AS')
       expect(client.credentials?).to be true
     end
-    it "returns false if any credentials are missing" do
-      client = Twitter::REST::Client.new(:consumer_key => "CK", :consumer_secret => "CS", :access_token => "AT")
+    it 'returns false if any credentials are missing' do
+      client = Twitter::REST::Client.new(:consumer_key => 'CK', :consumer_secret => 'CS', :access_token => 'AT')
       expect(client.credentials?).to be false
     end
   end
 
-  it "does not cache the screen name across clients" do
-    stub_get("/1.1/account/verify_credentials.json").to_return(:body => fixture("sferik.json"), :headers => {:content_type => "application/json; charset=utf-8"})
-    user1 = Twitter::REST::Client.new(:consumer_key => "CK", :consumer_secret => "CS", :access_token => "AT", :access_token_secret => "AS").current_user
-    stub_get("/1.1/account/verify_credentials.json").to_return(:body => fixture("pengwynn.json"), :headers => {:content_type => "application/json; charset=utf-8"})
-    user2 = Twitter::REST::Client.new(:consumer_key => "CK", :consumer_secret => "CS", :access_token => "AT", :access_token_secret => "AS").current_user
+  it 'does not cache the screen name across clients' do
+    stub_get('/1.1/account/verify_credentials.json').to_return(:body => fixture('sferik.json'), :headers => {:content_type => 'application/json; charset=utf-8'})
+    user1 = Twitter::REST::Client.new(:consumer_key => 'CK', :consumer_secret => 'CS', :access_token => 'AT', :access_token_secret => 'AS').current_user
+    stub_get('/1.1/account/verify_credentials.json').to_return(:body => fixture('pengwynn.json'), :headers => {:content_type => 'application/json; charset=utf-8'})
+    user2 = Twitter::REST::Client.new(:consumer_key => 'CK', :consumer_secret => 'CS', :access_token => 'AT', :access_token_secret => 'AS').current_user
     expect(user1).not_to eq(user2)
   end
 
-  describe "#delete" do
+  describe '#delete' do
     before do
-      stub_delete("/custom/delete").with(:query => {:deleted => "object"})
+      stub_delete('/custom/delete').with(:query => {:deleted => 'object'})
     end
-    it "allows custom delete requests" do
-      @client.delete("/custom/delete", {:deleted => "object"})
-      expect(a_delete("/custom/delete").with(:query => {:deleted => "object"})).to have_been_made
+    it 'allows custom delete requests' do
+      @client.delete('/custom/delete', :deleted => 'object')
+      expect(a_delete('/custom/delete').with(:query => {:deleted => 'object'})).to have_been_made
     end
   end
 
-  describe "#put" do
+  describe '#put' do
     before do
-      stub_put("/custom/put").with(:body => {:updated => "object"})
+      stub_put('/custom/put').with(:body => {:updated => 'object'})
     end
-    it "allows custom put requests" do
-      @client.put("/custom/put", {:updated => "object"})
-      expect(a_put("/custom/put").with(:body => {:updated => "object"})).to have_been_made
+    it 'allows custom put requests' do
+      @client.put('/custom/put', :updated => 'object')
+      expect(a_put('/custom/put').with(:body => {:updated => 'object'})).to have_been_made
     end
   end
 
-  describe "#user_token?" do
-    it "returns true if the user token/secret are present" do
-      client = Twitter::REST::Client.new(:consumer_key => "CK", :consumer_secret => "CS", :access_token => "AT", :access_token_secret => "AS")
+  describe '#user_token?' do
+    it 'returns true if the user token/secret are present' do
+      client = Twitter::REST::Client.new(:consumer_key => 'CK', :consumer_secret => 'CS', :access_token => 'AT', :access_token_secret => 'AS')
       expect(client.user_token?).to be true
     end
-    it "returns false if the user token/secret are not completely present" do
-      client = Twitter::REST::Client.new(:consumer_key => "CK", :consumer_secret => "CS", :access_token => "AT")
+    it 'returns false if the user token/secret are not completely present' do
+      client = Twitter::REST::Client.new(:consumer_key => 'CK', :consumer_secret => 'CS', :access_token => 'AT')
       expect(client.user_token?).to be false
     end
   end
 
-  describe "#bearer_token?" do
-    it "returns true if the app token is present" do
-      client = Twitter::REST::Client.new(:consumer_key => "CK", :consumer_secret => "CS", :bearer_token => "BT")
+  describe '#bearer_token?' do
+    it 'returns true if the app token is present' do
+      client = Twitter::REST::Client.new(:consumer_key => 'CK', :consumer_secret => 'CS', :bearer_token => 'BT')
       expect(client.bearer_token?).to be true
     end
-    it "returns false if the bearer_token is not present" do
-      client = Twitter::REST::Client.new(:consumer_key => "CK", :consumer_secret => "CS")
+    it 'returns false if the bearer_token is not present' do
+      client = Twitter::REST::Client.new(:consumer_key => 'CK', :consumer_secret => 'CS')
       expect(client.bearer_token?).to be false
     end
   end
 
-  describe "#credentials?" do
-    it "returns true if all credentials are present" do
-      client = Twitter::REST::Client.new(:consumer_key => "CK", :consumer_secret => "CS", :access_token => "AT", :access_token_secret => "AS")
+  describe '#credentials?' do
+    it 'returns true if all credentials are present' do
+      client = Twitter::REST::Client.new(:consumer_key => 'CK', :consumer_secret => 'CS', :access_token => 'AT', :access_token_secret => 'AS')
       expect(client.credentials?).to be true
     end
-    it "returns false if any credentials are missing" do
-      client = Twitter::REST::Client.new(:consumer_key => "CK", :consumer_secret => "CS", :access_token => "AT")
+    it 'returns false if any credentials are missing' do
+      client = Twitter::REST::Client.new(:consumer_key => 'CK', :consumer_secret => 'CS', :access_token => 'AT')
       expect(client.credentials?).to be false
     end
   end
 
-  describe "#connection" do
-    it "looks like Faraday connection" do
+  describe '#connection' do
+    it 'looks like Faraday connection' do
       expect(@client.send(:connection)).to respond_to(:run_request)
     end
-    it "memoizes the connection" do
+    it 'memoizes the connection' do
       c1, c2 = @client.send(:connection), @client.send(:connection)
       expect(c1.object_id).to eq(c2.object_id)
     end
   end
 
-  describe "#request" do
-    it "encodes the entire body when no uploaded media is present" do
-      stub_post("/1.1/statuses/update.json").with(:body => {:status => "Update"}).to_return(:body => fixture("status.json"), :headers => {:content_type => "application/json; charset=utf-8"})
-      @client.update("Update")
-      expect(a_post("/1.1/statuses/update.json").with(:body => {:status => "Update"})).to have_been_made
+  describe '#request' do
+    it 'encodes the entire body when no uploaded media is present' do
+      stub_post('/1.1/statuses/update.json').with(:body => {:status => 'Update'}).to_return(:body => fixture('status.json'), :headers => {:content_type => 'application/json; charset=utf-8'})
+      @client.update('Update')
+      expect(a_post('/1.1/statuses/update.json').with(:body => {:status => 'Update'})).to have_been_made
     end
-    it "encodes none of the body when uploaded media is present" do
-      stub_post("/1.1/statuses/update_with_media.json").to_return(:body => fixture("status.json"), :headers => {:content_type => "application/json; charset=utf-8"})
-      @client.update_with_media("Update", fixture("pbjt.gif"))
-      expect(a_post("/1.1/statuses/update_with_media.json")).to have_been_made
+    it 'encodes none of the body when uploaded media is present' do
+      stub_post('/1.1/statuses/update_with_media.json').to_return(:body => fixture('status.json'), :headers => {:content_type => 'application/json; charset=utf-8'})
+      @client.update_with_media('Update', fixture('pbjt.gif'))
+      expect(a_post('/1.1/statuses/update_with_media.json')).to have_been_made
     end
-    it "catches Faraday errors" do
-      allow(@client).to receive(:connection).and_raise(Faraday::Error::ClientError.new("Oops"))
-      expect{@client.send(:request, :get, "/path")}.to raise_error Twitter::Error
+    it 'catches Faraday errors' do
+      allow(@client).to receive(:connection).and_raise(Faraday::Error::ClientError.new('Oops'))
+      expect { @client.send(:request, :get, '/path') }.to raise_error Twitter::Error
     end
-    it "catches JSON::ParserError errors" do
-      allow(@client).to receive(:connection).and_raise(JSON::ParserError.new("unexpected token"))
-      expect{@client.send(:request, :get, "/path")}.to raise_error Twitter::Error
+    it 'catches JSON::ParserError errors' do
+      allow(@client).to receive(:connection).and_raise(JSON::ParserError.new('unexpected token'))
+      expect { @client.send(:request, :get, '/path') }.to raise_error Twitter::Error
     end
   end
 
-  describe "#oauth_auth_header" do
-    it "creates the correct auth headers" do
-      uri = Twitter::REST::Client::ENDPOINT + "/1.1/direct_messages.json"
+  describe '#oauth_auth_header' do
+    it 'creates the correct auth headers' do
+      uri = Twitter::REST::Client::ENDPOINT + '/1.1/direct_messages.json'
       authorization = @client.send(:oauth_auth_header, :get, uri)
-      expect(authorization.options[:signature_method]).to eq("HMAC-SHA1")
-      expect(authorization.options[:version]).to eq("1.0")
-      expect(authorization.options[:consumer_key]).to eq("CK")
-      expect(authorization.options[:consumer_secret]).to eq("CS")
-      expect(authorization.options[:token]).to eq("AT")
-      expect(authorization.options[:token_secret]).to eq("AS")
-    end
-    it "submits the correct auth header when no media is present" do
+      expect(authorization.options[:signature_method]).to eq('HMAC-SHA1')
+      expect(authorization.options[:version]).to eq('1.0')
+      expect(authorization.options[:consumer_key]).to eq('CK')
+      expect(authorization.options[:consumer_secret]).to eq('CS')
+      expect(authorization.options[:token]).to eq('AT')
+      expect(authorization.options[:token_secret]).to eq('AS')
+    end
+    it 'submits the correct auth header when no media is present' do
       # We use static values for nounce and timestamp to get a stable signature
-      secret = {:consumer_key => "CK", :consumer_secret => "CS",
-                :token => "OT", :token_secret => "OS",
-                :nonce => "b6ebe4c2a11af493f8a2290fe1296965", :timestamp => "1370968658"}
-      header = {"Authorization" => /oauth_signature="FbthwmgGq02iQw%2FuXGEWaL6V6eM%3D"/}
+      secret = {:consumer_key => 'CK', :consumer_secret => 'CS',
+                :token => 'OT', :token_secret => 'OS',
+                :nonce => 'b6ebe4c2a11af493f8a2290fe1296965', :timestamp => '1370968658'}
+      header = {'Authorization' => /oauth_signature="FbthwmgGq02iQw%2FuXGEWaL6V6eM%3D"/}
 
       allow(@client).to receive(:credentials).and_return(secret)
-      stub_post("/1.1/statuses/update.json").with(:body => {:status => "Just a test"}).to_return(:body => fixture("status.json"), :headers => {:content_type => "application/json; charset=utf-8"})
-      @client.update("Just a test")
-      expect(a_post("/1.1/statuses/update.json").
+      stub_post('/1.1/statuses/update.json').with(:body => {:status => 'Just a test'}).to_return(:body => fixture('status.json'), :headers => {:content_type => 'application/json; charset=utf-8'})
+      @client.update('Just a test')
+      expect(a_post('/1.1/statuses/update.json').
              with(:headers => header)).to have_been_made
     end
-    it "submits the correct auth header when media is present" do
+    it 'submits the correct auth header when media is present' do
       # We use static values for nounce and timestamp to get a stable signature
-      secret = {:consumer_key => "CK", :consumer_secret => "CS",
-                :token => "OT", :token_secret => "OS",
-                :nonce => "e08201ad0dab4897c99445056feefd95", :timestamp => "1370967652"}
-      header = {"Authorization" => /oauth_signature="9ziouUPwZT9IWWRbJL8r0BerKYA%3D"/}
+      secret = {:consumer_key => 'CK', :consumer_secret => 'CS',
+                :token => 'OT', :token_secret => 'OS',
+                :nonce => 'e08201ad0dab4897c99445056feefd95', :timestamp => '1370967652'}
+      header = {'Authorization' => /oauth_signature="9ziouUPwZT9IWWRbJL8r0BerKYA%3D"/}
 
       allow(@client).to receive(:credentials).and_return(secret)
-      stub_post("/1.1/statuses/update_with_media.json").to_return(:body => fixture("status.json"), :headers => header)
-      @client.update_with_media("Just a test", fixture("pbjt.gif"))
-      expect(a_post("/1.1/statuses/update_with_media.json").
+      stub_post('/1.1/statuses/update_with_media.json').to_return(:body => fixture('status.json'), :headers => header)
+      @client.update_with_media('Just a test', fixture('pbjt.gif'))
+      expect(a_post('/1.1/statuses/update_with_media.json').
              with(:headers => header)).to have_been_made
     end
   end
 
-  describe "#bearer_auth_header" do
-    it "creates the correct auth headers with supplied bearer_token" do
-      client = Twitter::REST::Client.new(:bearer_token => "BT")
+  describe '#bearer_auth_header' do
+    it 'creates the correct auth headers with supplied bearer_token' do
+      client = Twitter::REST::Client.new(:bearer_token => 'BT')
       authorization = client.send(:bearer_auth_header)
-      expect(authorization).to eq("Bearer BT")
+      expect(authorization).to eq('Bearer BT')
     end
-    it "creates the correct auth headers with supplied bearer token" do
-      token = Twitter::Token.new(:token_type => "bearer", :access_token => "BT")
+    it 'creates the correct auth headers with supplied bearer token' do
+      token = Twitter::Token.new(:token_type => 'bearer', :access_token => 'BT')
       client = Twitter::REST::Client.new(:bearer_token => token)
       authorization = client.send(:bearer_auth_header)
-      expect(authorization).to eq("Bearer BT")
+      expect(authorization).to eq('Bearer BT')
     end
   end
 
-  describe "#bearer_token_credentials_auth_header" do
-    it "creates the correct auth header with supplied consumer_key and consumer_secret" do
+  describe '#bearer_token_credentials_auth_header' do
+    it 'creates the correct auth header with supplied consumer_key and consumer_secret' do
       authorization = @client.send(:bearer_token_credentials_auth_header)
-      expect(authorization).to eq("Basic Q0s6Q1M=")
+      expect(authorization).to eq('Basic Q0s6Q1M=')
     end
   end
 end

data/spec/twitter/saved_search_spec.rb

@@ -2,42 +2,42 @@ require 'helper'
 
 describe Twitter::SavedSearch do
 
-  describe "#==" 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")
+  describe '#==' 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')
       expect(saved_search == other).to be true
     end
-    it "returns false when objects IDs are different" do
+    it 'returns false when objects IDs are different' do
       saved_search = Twitter::SavedSearch.new(:id => 1)
       other = Twitter::SavedSearch.new(:id => 2)
       expect(saved_search == other).to be false
     end
-    it "returns false when classes are different" do
+    it 'returns false when classes are different' do
       saved_search = Twitter::SavedSearch.new(:id => 1)
       other = Twitter::Identity.new(:id => 1)
       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")
+  describe '#created_at' do
+    it 'returns a Time when created_at is set' do
+      saved_search = Twitter::SavedSearch.new(:id => 16_129_012, :created_at => 'Mon Jul 16 12:59:01 +0000 2007')
       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)
+    it 'returns nil when created_at is not set' do
+      saved_search = Twitter::SavedSearch.new(:id => 16_129_012)
       expect(saved_search.created_at).to be_nil
     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")
+  describe '#created?' do
+    it 'returns true when created_at is set' do
+      saved_search = Twitter::SavedSearch.new(:id => 16_129_012, :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)
+    it 'returns false when created_at is not set' do
+      saved_search = Twitter::SavedSearch.new(:id => 16_129_012)
       expect(saved_search.created?).to be false
     end
   end

data/spec/twitter/search_results_spec.rb

@@ -2,124 +2,124 @@ require 'helper'
 
 describe Twitter::SearchResults do
 
-  describe "#each" do
+  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
+    it 'iterates' do
       count = 0
-      @search_results.each{count += 1}
+      @search_results.each { count += 1 }
       expect(count).to eq(6)
     end
-    context "with start" do
-      it "iterates" do
+    context 'with start' do
+      it 'iterates' do
         count = 0
-        @search_results.each(5){count += 1}
+        @search_results.each(5) { count += 1 }
         expect(count).to eq(1)
       end
     end
   end
 
-  describe "#completed_in" do
-    it "returns a number of seconds" do
+  describe '#completed_in' 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)
     end
-    it "is nil when not set" do
+    it 'is nil when not set' do
       completed_in = Twitter::SearchResults.new.completed_in
       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
+  describe '#max_id' do
+    it 'returns an ID' do
+      max_id = Twitter::SearchResults.new(:search_metadata => {:max_id => 250_126_199_840_518_145}).max_id
       expect(max_id).to be_an Integer
-      expect(max_id).to eq(250126199840518145)
+      expect(max_id).to eq(250_126_199_840_518_145)
     end
-    it "is nil when not set" do
+    it 'is nil when not set' do
       max_id = Twitter::SearchResults.new.max_id
       expect(max_id).to be_nil
     end
   end
 
-  describe "#page" do
-    it "returns page number" do
+  describe '#page' 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)
     end
-    it "is nil when not set" do
+    it 'is nil when not set' do
       page = Twitter::SearchResults.new.page
       expect(page).to be_nil
     end
   end
 
-  describe "#query" do
-    it "returns the query" do
-      query = Twitter::SearchResults.new(:search_metadata => {:query => "%23freebandnames"}).query
+  describe '#query' 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
+    it 'is nil when not set' do
       query = Twitter::SearchResults.new.query
       expect(query).to be_nil
     end
   end
 
-  describe "#results_per_page" do
-    it "returns the number of results per page" do
+  describe '#results_per_page' do
+    it 'returns the number of results per page' do
       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)
     end
-    it "is nil when not set" do
+    it 'is nil when not set' do
       results_per_page = Twitter::SearchResults.new.results_per_page
       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
+  describe '#since_id' do
+    it 'returns an ID' do
+      since_id = Twitter::SearchResults.new(:search_metadata => {:since_id => 250_126_199_840_518_145}).since_id
       expect(since_id).to be_an Integer
-      expect(since_id).to eq(250126199840518145)
+      expect(since_id).to eq(250_126_199_840_518_145)
     end
-    it "is nil when not set" do
+    it 'is nil when not set' do
       since_id = Twitter::SearchResults.new.since_id
       expect(since_id).to be_nil
     end
   end
 
-  describe "#next_results?" do
-    it "returns true when next_results is set" do
-      next_results = Twitter::SearchResults.new(:search_metadata => {:next_results => "?"}).next_results?
+  describe '#next_results?' do
+    it 'returns true when next_results is set' do
+      next_results = Twitter::SearchResults.new(:search_metadata => {:next_results => '?'}).next_results?
       expect(next_results).to be true
     end
-    it "returns false when next_results is not set" do
+    it 'returns false when next_results is not set' do
       next_results = Twitter::SearchResults.new(:search_metadata => {}).next_results?
       expect(next_results).to be false
     end
-    it "returns false is search_metadata is not set" do
-      next_results = Twitter::SearchResults.new().next_results?
+    it 'returns false is search_metadata is not set' do
+      next_results = Twitter::SearchResults.new.next_results?
       expect(next_results).to be false
     end
   end
 
-  describe "#next_results" do
-    it "returns a hash of query parameters" do
-      search_results = Twitter::SearchResults.new(:search_metadata => {:next_results => "?max_id=249279667666817023&q=%23freebandnames&count=4&include_entities=1&result_type=mixed"})
+  describe '#next_results' do
+    it 'returns a hash of query parameters' do
+      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")
+      expect(search_results.next_results[:max_id]).to eq('249279667666817023')
     end
   end
 
-  describe "#refresh_results" do
-    it "returns a hash of query parameters" do
-      search_results = Twitter::SearchResults.new(:search_metadata => {:refresh_url => "?since_id=249279667666817023&q=%23freebandnames&count=4&include_entities=1&result_type=recent"})
+  describe '#refresh_results' do
+    it 'returns a hash of query parameters' do
+      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")
+      expect(search_results.refresh_results[:since_id]).to eq('249279667666817023')
     end
   end