tweetwine 0.2.5 → 0.2.7

data/test/client_test.rb

@@ -1,18 +1,17 @@
 require "test_helper"
 require "json"
 
-Mocha::Configuration.allow(:stubbing_non_existent_method)
-
 module Tweetwine
 
 class ClientTest < Test::Unit::TestCase
   context "A client instance" do
     setup do
       @io = mock()
-      @rest_client = mock()
+      @http_resource = mock()
+      @http_client = stub({ :as_resource => @http_resource })
       @url_shortener = mock()
-      url_shortener = lambda { |options| @url_shortener }
-      @deps = Client::Dependencies.new @io, @rest_client, url_shortener
+      @url_shortener_block = lambda { |options| @url_shortener }
+      @deps = Client::Dependencies.new @io, @http_client, @url_shortener_block
     end
 
     context "upon initialization" do
@@ -50,6 +49,13 @@ class ClientTest < Test::Unit::TestCase
       should "raise an exception for configured page number if not in allowed range" do
         assert_raise(ArgumentError) { Client.new(@deps, { :username => "foo", :password => "bar", :page_num => 0 }) }
       end
+
+      should "user proper base URL and authentication information for HTTP requests" do
+        http_client = mock()
+        http_client.expects(:as_resource).with("https://twitter.com", :user => "foo", :password => "bar")
+        deps = Client::Dependencies.new @io, http_client, @url_shortener_block
+        Client.new(deps, { :username => "foo", :password => "bar" })
+      end
     end
 
     context "at runtime" do
@@ -57,160 +63,153 @@ class ClientTest < Test::Unit::TestCase
         @username = "spiky"
         @password = "lullaby"
         @client = Client.new(@deps, { :username => @username, :password => @password })
-        @base_url = "https://#{@username}:#{@password}@twitter.com"
-        @statuses_query_params = "count=#{Client::DEFAULT_NUM_STATUSES}&page=#{Client::DEFAULT_PAGE_NUM}"
-        @users_query_params = "page=#{Client::DEFAULT_PAGE_NUM}"
+        @rest_api_status_query_str = "count=#{Client::DEFAULT_NUM_STATUSES}&page=#{Client::DEFAULT_PAGE_NUM}"
+        @search_api_base_url = "http://search.twitter.com/search.json"
+        @search_api_query_str = "rpp=#{Client::DEFAULT_NUM_STATUSES}&page=#{Client::DEFAULT_PAGE_NUM}"
       end
 
       should "fetch friends' statuses (home view)" do
-        status_records, gen_records = create_test_statuses(
+        twitter_records, internal_records = create_test_twitter_status_records_from_rest_api(
           {
-            :user => "zanzibar",
-            :status => {
-              :created_at   => Time.at(1).to_s,
-              :text         => "wassup?",
-              :in_reply_to  => nil
-            }
+            :from_user  => "zanzibar",
+            :status     => "wassup?",
+            :created_at => Time.at(1).to_s,
+            :to_user    => nil
           },
           {
-            :user => "lulzwoo",
-            :status => {
-              :created_at   => Time.at(1).to_s,
-              :text         => "nuttin'",
-              :in_reply_to  => nil
-            }
+            :from_user  => "lulzwoo",
+            :status     => "nuttin'",
+            :created_at => Time.at(1).to_s,
+            :to_user    => nil
           }
         )
-        @rest_client.expects(:get) \
-            .with("#{@base_url}/statuses/friends_timeline.json?#{@statuses_query_params}") \
-            .returns(status_records.to_json)
-        @io.expects(:show_record).with(gen_records[0])
-        @io.expects(:show_record).with(gen_records[1])
+        @http_resource.expects(:[]) \
+                      .with("statuses/home_timeline.json?#{@rest_api_status_query_str}") \
+                      .returns(stub(:get => twitter_records.to_json))
+        @io.expects(:show_record).with(internal_records[0])
+        @io.expects(:show_record).with(internal_records[1])
         @client.home
       end
 
       should "fetch mentions" do
-        status_records, gen_records = create_test_statuses(
+        twitter_records, internal_records = create_test_twitter_status_records_from_rest_api(
           {
-            :user => "zanzibar",
-            :status => {
-              :created_at   => Time.at(1).to_s,
-              :text         => "wassup, @#{@username}?",
-              :in_reply_to  => @username
-            }
+            :from_user  => "zanzibar",
+            :status     => "wassup, @#{@username}?",
+            :created_at => Time.at(1).to_s,
+            :to_user    => @username
           },
           {
-            :user => "lulzwoo",
-            :status => {
-              :created_at   => Time.at(1).to_s,
-              :text         => "@#{@username}, doing nuttin'",
-              :in_reply_to  => @username
-            }
+            :from_user  => "lulzwoo",
+            :status     => "@#{@username}, doing nuttin'",
+            :created_at => Time.at(1).to_s,
+            :to_user    => @username
           }
         )
-        @rest_client.expects(:get) \
-            .with("#{@base_url}/statuses/mentions.json?#{@statuses_query_params}") \
-            .returns(status_records.to_json)
-        @io.expects(:show_record).with(gen_records[0])
-        @io.expects(:show_record).with(gen_records[1])
+        @http_resource.expects(:[]) \
+                      .with("statuses/mentions.json?#{@rest_api_status_query_str}") \
+                      .returns(stub(:get => twitter_records.to_json))
+        @io.expects(:show_record).with(internal_records[0])
+        @io.expects(:show_record).with(internal_records[1])
         @client.mentions
       end
 
       should "fetch a specific user's statuses, when the user identified by given argument" do
         user = "spoonman"
-        status_records, gen_records = create_test_statuses(
+        twitter_records, internal_records = create_test_twitter_status_records_from_rest_api(
           {
-            :user => user,
-            :status => {
-              :created_at   => Time.at(1).to_s,
-              :text         => "wassup?",
-              :in_reply_to  => nil
-            }
+            :from_user  => user,
+            :status     => "wassup?",
+            :created_at => Time.at(1).to_s,
+            :to_user    => nil
           }
         )
-        @rest_client.expects(:get) \
-            .with("#{@base_url}/statuses/user_timeline/#{user}.json?#{@statuses_query_params}") \
-            .returns(status_records.to_json)
-        @io.expects(:show_record).with(gen_records[0])
-        @client.user(user)
+        @http_resource.expects(:[]) \
+                      .with("statuses/user_timeline/#{user}.json?#{@rest_api_status_query_str}") \
+                      .returns(stub(:get => twitter_records.to_json))
+        @io.expects(:show_record).with(internal_records[0])
+        @client.user([user])
       end
 
       should "fetch a specific user's statuses, with the user being the authenticated user itself when given no argument" do
-        status_records, gen_records = create_test_statuses(
+        twitter_records, internal_records = create_test_twitter_status_records_from_rest_api(
           {
-            :user => @username,
-            :status => {
-              :created_at   => Time.at(1).to_s,
-              :text         => "wassup?",
-              :in_reply_to  => nil
-            }
+            :from_user  => @username,
+            :status     => "wassup?",
+            :created_at => Time.at(1).to_s,
+            :to_user    => nil
           }
         )
-        @rest_client.expects(:get) \
-            .with("#{@base_url}/statuses/user_timeline/#{@username}.json?#{@statuses_query_params}") \
-            .returns(status_records.to_json)
-        @io.expects(:show_record).with(gen_records[0])
+        @http_resource.expects(:[]) \
+                      .with("statuses/user_timeline/#{@username}.json?#{@rest_api_status_query_str}") \
+                      .returns(stub(:get => twitter_records.to_json))
+        @io.expects(:show_record).with(internal_records[0])
         @client.user
       end
 
       context "for posting status updates" do
         should "post a status update via argument, when positive confirmation" do
           status = "wondering around"
-          status_records, gen_records = create_test_statuses(
+          twitter_records, internal_records = create_test_twitter_status_records_from_rest_api(
             {
-              :user => @username,
-              :status => {
-                :created_at   => Time.at(1).to_s,
-                :text         => status,
-                :in_reply_to  => nil
-              }
+              :from_user  => @username,
+              :status     => status,
+              :created_at => Time.at(1).to_s,
+              :to_user    => nil
             }
           )
-          @rest_client.expects(:post) \
-              .with("#{@base_url}/statuses/update.json", {:status => status}) \
-              .returns(status_records[0].to_json)
+          http_subresource = mock()
+          http_subresource.expects(:post) \
+                          .with({ :status => status }) \
+                          .returns(twitter_records[0].to_json)
+          @http_resource.expects(:[]) \
+                        .with("statuses/update.json") \
+                        .returns(http_subresource)
           @io.expects(:confirm).with("Really send?").returns(true)
           @io.expects(:show_status_preview).with(status)
           @io.expects(:info).with("Sent status update.\n\n")
-          @io.expects(:show_record).with(gen_records[0])
-          @client.update(status)
+          @io.expects(:show_record).with(internal_records[0])
+          @client.update([status])
         end
 
         should "post a status update via prompt, when positive confirmation" do
           status = "wondering around"
-          status_records, gen_records = create_test_statuses(
-            { :user => @username,
-              :status => {
-                :created_at   => Time.at(1).to_s,
-                :text         => status,
-                :in_reply_to  => nil
-              }
+          twitter_records, internal_records = create_test_twitter_status_records_from_rest_api(
+            {
+              :from_user  => @username,
+              :status     => status,
+              :created_at => Time.at(1).to_s,
+              :to_user    => nil
             }
           )
-          @rest_client.expects(:post) \
-              .with("#{@base_url}/statuses/update.json", {:status => status}) \
-              .returns(status_records[0].to_json)
+          http_subresource = mock()
+          http_subresource.expects(:post) \
+                          .with({ :status => status }) \
+                          .returns(twitter_records[0].to_json)
+          @http_resource.expects(:[]) \
+                        .with("statuses/update.json") \
+                        .returns(http_subresource)
           @io.expects(:prompt).with("Status update").returns(status)
           @io.expects(:show_status_preview).with(status)
           @io.expects(:confirm).with("Really send?").returns(true)
           @io.expects(:info).with("Sent status update.\n\n")
-          @io.expects(:show_record).with(gen_records[0])
+          @io.expects(:show_record).with(internal_records[0])
           @client.update
         end
 
         should "cancel a status update via argument, when negative confirmation" do
           status = "wondering around"
-          @rest_client.expects(:post).never
+          @http_resource.expects(:[]).never
           @io.expects(:show_status_preview).with(status)
           @io.expects(:confirm).with("Really send?").returns(false)
           @io.expects(:info).with("Cancelled.")
           @io.expects(:show_record).never
-          @client.update(status)
+          @client.update([status])
         end
 
         should "cancel a status update via prompt, when negative confirmation" do
           status = "wondering around"
-          @rest_client.expects(:post).never
+          @http_resource.expects(:[]).never
           @io.expects(:prompt).with("Status update").returns(status)
           @io.expects(:show_status_preview).with(status)
           @io.expects(:confirm).with("Really send?").returns(false)
@@ -220,15 +219,15 @@ class ClientTest < Test::Unit::TestCase
         end
 
         should "cancel a status update via argument, when empty status" do
-          @rest_client.expects(:post).never
+          @http_resource.expects(:[]).never
           @io.expects(:confirm).never
           @io.expects(:info).with("Cancelled.")
           @io.expects(:show_record).never
-          @client.update("")
+          @client.update([""])
         end
 
         should "cancel a status update via prompt, when empty status" do
-          @rest_client.expects(:post).never
+          @http_resource.expects(:[]).never
           @io.expects(:prompt).with("Status update").returns("")
           @io.expects(:confirm).never
           @io.expects(:info).with("Cancelled.")
@@ -239,46 +238,52 @@ class ClientTest < Test::Unit::TestCase
         should "remove excess whitespace around a status update" do
           whitespaced_status = "  oh, i was sloppy \t   "
           stripped_status = "oh, i was sloppy"
-          status_records, gen_records = create_test_statuses(
-            { :user => @username,
-              :status => {
-                :created_at   => Time.at(1).to_s,
-                :text         => stripped_status,
-                :in_reply_to  => nil
-              }
+          twitter_records, internal_records = create_test_twitter_status_records_from_rest_api(
+            {
+              :from_user  => @username,
+              :status     => stripped_status,
+              :created_at => Time.at(1).to_s,
+              :to_user    => nil
             }
           )
-          @rest_client.expects(:post) \
-              .with("#{@base_url}/statuses/update.json", {:status => stripped_status}) \
-              .returns(status_records[0].to_json)
+          http_subresource = mock()
+          http_subresource.expects(:post) \
+                          .with({ :status => stripped_status }) \
+                          .returns(twitter_records[0].to_json)
+          @http_resource.expects(:[]) \
+                        .with("statuses/update.json") \
+                        .returns(http_subresource)
           @io.expects(:show_status_preview).with(stripped_status)
           @io.expects(:confirm).with("Really send?").returns(true)
           @io.expects(:info).with("Sent status update.\n\n")
-          @io.expects(:show_record).with(gen_records[0])
-          @client.update(whitespaced_status)
+          @io.expects(:show_record).with(internal_records[0])
+          @client.update([whitespaced_status])
         end
 
         should "truncate a status update with too long argument and warn the user" do
           long_status = "x aaa bbb ccc ddd eee fff ggg hhh iii jjj kkk lll mmm nnn ooo ppp qqq rrr sss ttt uuu vvv www xxx yyy zzz 111 222 333 444 555 666 777 888 999 000"
           truncated_status = "x aaa bbb ccc ddd eee fff ggg hhh iii jjj kkk lll mmm nnn ooo ppp qqq rrr sss ttt uuu vvv www xxx yyy zzz 111 222 333 444 555 666 777 888 99"
-          status_records, gen_records = create_test_statuses(
-            { :user => @username,
-              :status => {
-                :created_at   => Time.at(1).to_s,
-                :text         => truncated_status,
-                :in_reply_to  => nil
-              }
+          twitter_records, internal_records = create_test_twitter_status_records_from_rest_api(
+            {
+              :from_user  => @username,
+              :status     => truncated_status,
+              :created_at => Time.at(1).to_s,
+              :to_user    => nil
             }
           )
-          @rest_client.expects(:post) \
-              .with("#{@base_url}/statuses/update.json", {:status => truncated_status}) \
-              .returns(status_records[0].to_json)
+          http_subresource = mock()
+          http_subresource.expects(:post) \
+                          .with({ :status => truncated_status }) \
+                          .returns(twitter_records[0].to_json)
+          @http_resource.expects(:[]) \
+                        .with("statuses/update.json") \
+                        .returns(http_subresource)
           @io.expects(:warn).with("Status will be truncated.")
           @io.expects(:show_status_preview).with(truncated_status)
           @io.expects(:confirm).with("Really send?").returns(true)
           @io.expects(:info).with("Sent status update.\n\n")
-          @io.expects(:show_record).with(gen_records[0])
-          @client.update(long_status)
+          @io.expects(:show_record).with(internal_records[0])
+          @client.update([long_status])
         end
 
         context "with URL shortening enabled" do
@@ -301,50 +306,56 @@ class ClientTest < Test::Unit::TestCase
             long_status = long_urls.join(" and ")
             short_urls = ["http://shorten.it/2k7i8", "http://shorten.it/2k7mk"]
             shortened_status = short_urls.join(" and ")
-            status_records, gen_records = create_test_statuses(
-              { :user => @username,
-                :status => {
-                  :created_at   => Time.at(1).to_s,
-                  :text         => shortened_status,
-                  :in_reply_to  => nil
-                }
+            twitter_records, internal_records = create_test_twitter_status_records_from_rest_api(
+              {
+                :from_user  => @username,
+                :status     => shortened_status,
+                :created_at => Time.at(1).to_s,
+                :to_user    => nil
               }
             )
-            @rest_client.expects(:post) \
-                .with("#{@base_url}/statuses/update.json", {:status => shortened_status}) \
-                .returns(status_records[0].to_json)
+            http_subresource = mock()
+            http_subresource.expects(:post) \
+                            .with({ :status => shortened_status }) \
+                            .returns(twitter_records[0].to_json)
+            @http_resource.expects(:[]) \
+                          .with("statuses/update.json") \
+                          .returns(http_subresource)
             @url_shortener.expects(:shorten).with(long_urls.first).returns(short_urls.first)
             @url_shortener.expects(:shorten).with(long_urls.last).returns(short_urls.last)
             @io.expects(:show_status_preview).with(shortened_status)
             @io.expects(:confirm).with("Really send?").returns(true)
             @io.expects(:info).with("Sent status update.\n\n")
-            @io.expects(:show_record).with(gen_records[0])
-            @client.update(long_status)
+            @io.expects(:show_record).with(internal_records[0])
+            @client.update([long_status])
           end
 
           should "discard obviously invalid shortened URLs, using originals instead" do
             long_urls = ["http://www.google.fi/", "http://www.w3.org/TR/1999/REC-xpath-19991116"]
             status = long_urls.join(" and ")
             short_urls = [nil, ""]
-            status_records, gen_records = create_test_statuses(
-              { :user => @username,
-                :status => {
-                  :created_at   => Time.at(1).to_s,
-                  :text         => status,
-                  :in_reply_to  => nil
-                }
+            twitter_records, internal_records = create_test_twitter_status_records_from_rest_api(
+              {
+                :from_user  => @username,
+                :status     => status,
+                :created_at => Time.at(1).to_s,
+                :to_user    => nil
               }
             )
-            @rest_client.expects(:post) \
-                .with("#{@base_url}/statuses/update.json", {:status => status}) \
-                .returns(status_records[0].to_json)
+            http_subresource = mock()
+            http_subresource.expects(:post) \
+                            .with({ :status => status }) \
+                            .returns(twitter_records[0].to_json)
+            @http_resource.expects(:[]) \
+                          .with("statuses/update.json") \
+                          .returns(http_subresource)
             @url_shortener.expects(:shorten).with(long_urls.first).returns(short_urls.first)
             @url_shortener.expects(:shorten).with(long_urls.last).returns(short_urls.last)
             @io.expects(:show_status_preview).with(status)
             @io.expects(:confirm).with("Really send?").returns(true)
             @io.expects(:info).with("Sent status update.\n\n")
-            @io.expects(:show_record).with(gen_records[0])
-            @client.update(status)
+            @io.expects(:show_record).with(internal_records[0])
+            @client.update([status])
           end
 
           should "reuse a shortened URL for duplicate long URLs" do
@@ -352,118 +363,177 @@ class ClientTest < Test::Unit::TestCase
             long_status = long_urls.join(" and ")
             short_url = "http://shorten.it/2k7mk"
             short_status = ([short_url] * 2).join(" and ")
-            status_records, gen_records = create_test_statuses(
-              { :user => @username,
-                :status => {
-                  :created_at   => Time.at(1).to_s,
-                  :text         => short_status,
-                  :in_reply_to  => nil
-                }
+            twitter_records, internal_records = create_test_twitter_status_records_from_rest_api(
+              {
+                :from_user  => @username,
+                :status     => short_status,
+                :created_at => Time.at(1).to_s,
+                :to_user    => nil
               }
             )
-            @rest_client.expects(:post) \
-                .with("#{@base_url}/statuses/update.json", {:status => short_status}) \
-                .returns(status_records[0].to_json)
+            http_subresource = mock()
+            http_subresource.expects(:post) \
+                            .with({ :status => short_status }) \
+                            .returns(twitter_records[0].to_json)
+            @http_resource.expects(:[]) \
+                          .with("statuses/update.json") \
+                          .returns(http_subresource)
             @url_shortener.expects(:shorten).with(long_urls.first).returns(short_url)
             @io.expects(:show_status_preview).with(short_status)
             @io.expects(:confirm).with("Really send?").returns(true)
             @io.expects(:info).with("Sent status update.\n\n")
-            @io.expects(:show_record).with(gen_records[0])
-            @client.update(long_status)
+            @io.expects(:show_record).with(internal_records[0])
+            @client.update([long_status])
           end
 
           context "in erroneous situations" do
             setup do
               @url = "http://www.w3.org/TR/1999/REC-xpath-19991116"
               @status = "skimming through #{@url}"
-              @status_records, @gen_records = create_test_statuses(
-                { :user => @username,
-                  :status => {
-                    :created_at   => Time.at(1).to_s,
-                    :text         => @status,
-                    :in_reply_to  => nil
-                  }
+              @twitter_records, @internal_records = create_test_twitter_status_records_from_rest_api(
+                {
+                  :from_user  => @username,
+                  :status     => @status,
+                  :created_at => Time.at(1).to_s,
+                  :to_user    => nil
                 }
               )
             end
 
             should "skip shortening URLs if required libraries are not found" do
-              @rest_client.expects(:post) \
-                  .with("#{@base_url}/statuses/update.json", {:status => @status}) \
-                  .returns(@status_records[0].to_json)
+              http_subresource = mock()
+              http_subresource.expects(:post) \
+                              .with({ :status => @status }) \
+                              .returns(@twitter_records[0].to_json)
+              @http_resource.expects(:[]) \
+                            .with("statuses/update.json") \
+                            .returns(http_subresource)
               @url_shortener.expects(:shorten).with(@url).raises(LoadError, "gem not found")
               @io.expects(:warn)
               @io.expects(:show_status_preview).with(@status)
               @io.expects(:confirm).with("Really send?").returns(true)
               @io.expects(:info).with("Sent status update.\n\n")
-              @io.expects(:show_record).with(@gen_records[0])
-              @client.update(@status)
+              @io.expects(:show_record).with(@internal_records[0])
+              @client.update([@status])
             end
 
             should "skip shortening URLs upon connection error to the URL shortening service" do
-              @rest_client.expects(:post) \
-                  .with("#{@base_url}/statuses/update.json", {:status => @status}) \
-                  .returns(@status_records[0].to_json)
-              @url_shortener.expects(:shorten).with(@url).raises(ClientError, "connection error")
+              http_subresource = mock()
+              http_subresource.expects(:post) \
+                              .with({ :status => @status }) \
+                              .returns(@twitter_records[0].to_json)
+              @http_resource.expects(:[]) \
+                            .with("statuses/update.json") \
+                            .returns(http_subresource)
+              @url_shortener.expects(:shorten).with(@url).raises(HttpError, "connection error")
               @io.expects(:warn)
               @io.expects(:show_status_preview).with(@status)
               @io.expects(:confirm).with("Really send?").returns(true)
               @io.expects(:info).with("Sent status update.\n\n")
-              @io.expects(:show_record).with(@gen_records[0])
-              @client.update(@status)
+              @io.expects(:show_record).with(@internal_records[0])
+              @client.update([@status])
             end
           end
         end
       end
 
       should "fetch friends" do
-        user_records, gen_records = create_test_users(
+        twitter_records, internal_records = create_test_twitter_user_records_from_rest_api(
           {
-            :user => "zanzibar",
-            :status => {
-              :created_at   => Time.at(1).to_s,
-              :text         => "wassup, @foo?",
-              :in_reply_to  => "foo"
-            }
+            :from_user  => "zanzibar",
+            :status     => "wassup, @foo?",
+            :created_at => Time.at(1).to_s,
+            :to_user    => "foo"
           },
           {
-            :user => "lulzwoo",
-            :status => {
-              :created_at   => Time.at(1).to_s,
-              :text         => "@foo, doing nuttin'",
-              :in_reply_to  => "foo"
-            }
+            :from_user  => "lulzwoo",
+            :status     => "@foo, doing nuttin'",
+            :created_at => Time.at(1).to_s,
+            :to_user    => "foo"
           }
         )
-        @rest_client.expects(:get) \
-            .with("#{@base_url}/statuses/friends/#{@username}.json?#{@users_query_params}") \
-            .returns(user_records.to_json)
-        @io.expects(:show_record).with(gen_records[0])
-        @io.expects(:show_record).with(gen_records[1])
+        @http_resource.expects(:[]) \
+                      .with("statuses/friends/#{@username}.json") \
+                      .returns(stub(:get => twitter_records.to_json))
+        @io.expects(:show_record).with(internal_records[0])
+        @io.expects(:show_record).with(internal_records[1])
         @client.friends
       end
 
       should "fetch followers" do
-        user_records, gen_records = create_test_users(
+        twitter_records, internal_records = create_test_twitter_user_records_from_rest_api(
           {
-            :user => "zanzibar",
-            :status => {
-              :created_at   => Time.at(1).to_s,
-              :text         => "wassup, @foo?",
-              :in_reply_to  => "foo"
-            }
+            :from_user  => "zanzibar",
+            :status     => "wassup, @foo?",
+            :created_at => Time.at(1).to_s,
+            :to_user    => "foo"
           },
           {
-            :user => "lulzwoo"
+            :from_user  => "lulzwoo",
+            :status     => nil,
+            :created_at => nil,
+            :to_user    => nil
           }
         )
-        @rest_client.expects(:get) \
-            .with("#{@base_url}/statuses/followers/#{@username}.json?#{@users_query_params}") \
-            .returns(user_records.to_json)
-        @io.expects(:show_record).with(gen_records[0])
-        @io.expects(:show_record).with(gen_records[1])
+        @http_resource.expects(:[]) \
+                      .with("statuses/followers/#{@username}.json") \
+                      .returns(stub(:get => twitter_records.to_json))
+        @io.expects(:show_record).with(internal_records[0])
+        @io.expects(:show_record).with(internal_records[1])
         @client.followers
       end
+
+      context "for searching tweets" do
+        should "raise exception if no search word is given" do
+          assert_raise(ArgumentError) { @client.search() }
+        end
+
+        should "allow searching for tweets that match all the given words" do
+          twitter_response, internal_records = create_test_twitter_records_from_search_api(
+            {
+              :from_user  => "zanzibar",
+              :status     => "@foo, wassup? #greets",
+              :created_at => Time.at(1).to_s,
+              :to_user    => "foo"
+            },
+            {
+              :from_user  => "spoonman",
+              :status     => "@foo long time no see #greets",
+              :created_at => Time.at(1).to_s,
+              :to_user    => "foo"
+            }
+          )
+          @http_client.expects(:get) \
+                      .with("#{@search_api_base_url}?q=%23greets%20%40foo&#{@search_api_query_str}") \
+                      .returns(twitter_response.to_json)
+          @io.expects(:show_record).with(internal_records[0])
+          @io.expects(:show_record).with(internal_records[1])
+          @client.search(["#greets", "@foo"])
+        end
+
+        should "allow searching for tweets that match any of the given words" do
+          twitter_response, internal_records = create_test_twitter_records_from_search_api(
+            {
+              :from_user  => "zanzibar",
+              :status     => "spinning around the floor #habits",
+              :created_at => Time.at(1).to_s,
+              :to_user    => "foo"
+            },
+            {
+              :from_user  => "spoonman",
+              :status     => "drinking coffee, again #neurotic",
+              :created_at => Time.at(1).to_s,
+              :to_user    => "foo"
+            }
+          )
+          @http_client.expects(:get) \
+                      .with("#{@search_api_base_url}?q=%23habits%20OR%20%23neurotic&#{@search_api_query_str}") \
+                      .returns(twitter_response.to_json)
+          @io.expects(:show_record).with(internal_records[0])
+          @io.expects(:show_record).with(internal_records[1])
+          @client.search(["#habits", "#neurotic"], {:bin_op => :or})
+        end
+      end
     end
   end
 end