tweetwine 0.4.1 → 0.4.2

data/test/unit/twitter_test.rb

@@ -1,11 +1,11 @@
 # coding: utf-8
 
-require "unit_helper"
+require 'unit/helper'
 
-module Tweetwine::Test
+module Tweetwine::Test::Unit
 
-class ClientTest < UnitTestCase
-  setup do
+class ClientTest < TestCase
+  before do
     @config = {
       :num_tweets => 20,
       :page       => 1
@@ -13,38 +13,38 @@ class ClientTest < UnitTestCase
     stub_config @config
   end
 
-  context "for initialization" do
-    should "use default number of statuses if not configured" do
+  describe "for initialization" do
+    it "uses default number of statuses if not configured" do
       @twitter = Twitter.new
       assert_equal @config[:num_tweets], @twitter.num_tweets
     end
 
-    should "use configured number of statuses if in allowed range" do
+    it "uses configured number of statuses if in allowed range" do
       @twitter = Twitter.new(:num_tweets => 12)
       assert_equal 12, @twitter.num_tweets
     end
 
-    should "raise exception if configured number of status not in allowed range" do
-      assert_raise(CommandLineError) { Twitter.new(:num_tweets => 0) }
+    it "raises exception if configured number of status not in allowed range" do
+      assert_raises(CommandLineError) { Twitter.new(:num_tweets => 0) }
     end
 
-    should "use default page number if not configured otherwise" do
+    it "uses default page number if not configured otherwise" do
       @twitter = Twitter.new
       assert_equal @config[:page], @twitter.page
     end
 
-    should "use configured page number if in allowed range" do
+    it "uses configured page number if in allowed range" do
       @twitter = Twitter.new(:page => 12)
       assert_equal 12, @twitter.page
     end
 
-    should "raise exception if configured page number not in allowed range" do
-      assert_raise(CommandLineError) { Twitter.new(:page => 0) }
+    it "raises exception if configured page number not in allowed range" do
+      assert_raises(CommandLineError) { Twitter.new(:page => 0) }
     end
   end
 
-  context "at runtime" do
-    setup do
+  describe "at runtime" do
+    before do
       mock_http
       mock_oauth
       mock_ui
@@ -58,7 +58,7 @@ class ClientTest < UnitTestCase
       @search_api_query_str = "page=#{@config[:page]}&rpp=#{@config[:num_tweets]}"
     end
 
-    should "skip showing an invalid tweet" do
+    it "skips showing an invalid tweet" do
       invalid_from_user = nil
       twitter_records, internal_records = create_rest_api_status_records(
         {
@@ -79,7 +79,7 @@ class ClientTest < UnitTestCase
       @twitter.home
     end
 
-    should "fetch friends' statuses (home view)" do
+    it "fetches friends' statuses (home view)" do
       twitter_records, internal_records = create_rest_api_status_records(
         {
           :from_user  => "zanzibar",
@@ -98,7 +98,7 @@ class ClientTest < UnitTestCase
       @twitter.home
     end
 
-    should "fetch mentions" do
+    it "fetches mentions" do
       twitter_records, internal_records = create_rest_api_status_records(
         {
           :from_user  => "zanzibar",
@@ -119,7 +119,7 @@ class ClientTest < UnitTestCase
       @twitter.mentions
     end
 
-    should "fetch a specific user's statuses, when user is given as argument" do
+    it "fetches a specific user's statuses, when user is given as argument" do
       username = "spoonman"
       twitter_records, internal_records = create_rest_api_status_records({
         :from_user  => username,
@@ -133,7 +133,7 @@ class ClientTest < UnitTestCase
       @twitter.user(username)
     end
 
-    should "fetch a specific user's statuses, with user being the authenticated user itself when given no argument" do
+    it "fetches a specific user's statuses, with user being the authenticated user itself when given no argument" do
       twitter_records, internal_records = create_rest_api_status_records({
         :from_user  => @username,
         :status     => "wassup?"
@@ -146,30 +146,197 @@ class ClientTest < UnitTestCase
       @twitter.user
     end
 
-    context "when posting status updates" do
-      should "post a status update via argument, when positive confirmation" do
-        status = "wondering around"
+    it "posts a status update via argument, when positive confirmation" do
+      status = "wondering around"
+      twitter_records, internal_records = create_rest_api_status_records({
+        :from_user  => @username,
+        :status     => status
+      })
+      @oauth.expects(:request_signer)
+      http_subresource = mock
+      http_subresource.expects(:post).
+        with({ :status => status }).
+        returns(twitter_records[0].to_json)
+      @rest_api.expects(:[]).
+        with("statuses/update.json").
+        returns(http_subresource)
+      @ui.expects(:confirm).with("Really send?").returns(true)
+      @ui.expects(:show_status_preview).with(status)
+      @ui.expects(:info).with("Sent status update.\n\n")
+      @ui.expects(:show_tweets).with(internal_records)
+      @twitter.update(status)
+    end
+
+    it "posts a status update via prompt, when positive confirmation" do
+      status = "wondering around"
+      twitter_records, internal_records = create_rest_api_status_records({
+        :from_user  => @username,
+        :status     => status
+      })
+      @oauth.expects(:request_signer)
+      http_subresource = mock
+      http_subresource.expects(:post).
+        with({ :status => status }).
+        returns(twitter_records[0].to_json)
+      @rest_api.expects(:[]).
+        with("statuses/update.json").
+        returns(http_subresource)
+      @ui.expects(:prompt).with("Status update").returns(status)
+      @ui.expects(:show_status_preview).with(status)
+      @ui.expects(:confirm).with("Really send?").returns(true)
+      @ui.expects(:info).with("Sent status update.\n\n")
+      @ui.expects(:show_tweets).with(internal_records)
+      @twitter.update
+    end
+
+    it "cancels a status update via argument, when negative confirmation" do
+      status = "wondering around"
+      @rest_api.expects(:[]).never
+      @ui.expects(:show_status_preview).with(status)
+      @ui.expects(:confirm).with("Really send?").returns(false)
+      @ui.expects(:info).with("Cancelled.")
+      @ui.expects(:show_tweets).never
+      @twitter.update(status)
+    end
+
+    it "cancels a status update via prompt, when negative confirmation" do
+      status = "wondering around"
+      @rest_api.expects(:[]).never
+      @ui.expects(:prompt).with("Status update").returns(status)
+      @ui.expects(:show_status_preview).with(status)
+      @ui.expects(:confirm).with("Really send?").returns(false)
+      @ui.expects(:info).with("Cancelled.")
+      @ui.expects(:show_tweets).never
+      @twitter.update
+    end
+
+    it "cancels a status update via argument, when empty status" do
+      @rest_api.expects(:[]).never
+      @ui.expects(:prompt).with("Status update").returns("")
+      @ui.expects(:confirm).never
+      @ui.expects(:info).with("Cancelled.")
+      @ui.expects(:show_tweets).never
+      @twitter.update("")
+    end
+
+    it "cancels a status update via prompt, when empty status" do
+      @rest_api.expects(:[]).never
+      @ui.expects(:prompt).with("Status update").returns("")
+      @ui.expects(:confirm).never
+      @ui.expects(:info).with("Cancelled.")
+      @ui.expects(:show_tweets).never
+      @twitter.update
+    end
+
+    it "removes excess whitespace around a status update" do
+      whitespaced_status = "  oh, i was sloppy \t   "
+      stripped_status = "oh, i was sloppy"
+      twitter_records, internal_records = create_rest_api_status_records({
+        :from_user  => @username,
+        :status     => stripped_status
+      })
+      @oauth.expects(:request_signer)
+      http_subresource = mock
+      http_subresource.expects(:post).
+        with({ :status => stripped_status }).
+        returns(twitter_records[0].to_json)
+      @rest_api.expects(:[]).
+        with("statuses/update.json").
+        returns(http_subresource)
+      @ui.expects(:show_status_preview).with(stripped_status)
+      @ui.expects(:confirm).with("Really send?").returns(true)
+      @ui.expects(:info).with("Sent status update.\n\n")
+      @ui.expects(:show_tweets).with(internal_records)
+      @twitter.update(whitespaced_status)
+    end
+
+    it "truncates a status update with too long argument and warn the user" do
+      truncated_status = "ab c" * 35  #  4 * 35 = 140
+      long_status = "#{truncated_status} dd"
+      twitter_records, internal_records = create_rest_api_status_records({
+        :from_user  => @username,
+        :status     => truncated_status
+      })
+      @oauth.expects(:request_signer)
+      http_subresource = mock
+      http_subresource.expects(:post).
+        with({ :status => truncated_status }).
+        returns(twitter_records[0].to_json)
+      @rest_api.expects(:[]).
+        with("statuses/update.json").
+        returns(http_subresource)
+      @ui.expects(:warn).with("Status will be truncated.")
+      @ui.expects(:show_status_preview).with(truncated_status)
+      @ui.expects(:confirm).with("Really send?").returns(true)
+      @ui.expects(:info).with("Sent status update.\n\n")
+      @ui.expects(:show_tweets).with(internal_records)
+      @twitter.update(long_status)
+    end
+
+    if defined? Encoding
+      it "encodes status in UTF-8 (String supports encoding)" do
+        status_utf8, status_latin1 = "résumé", "résumé".encode('ISO-8859-1')
         twitter_records, internal_records = create_rest_api_status_records({
           :from_user  => @username,
-          :status     => status
+          :status     => status_utf8
         })
         @oauth.expects(:request_signer)
         http_subresource = mock
         http_subresource.expects(:post).
-          with({ :status => status }).
+          with({ :status => status_utf8 }).
           returns(twitter_records[0].to_json)
         @rest_api.expects(:[]).
           with("statuses/update.json").
           returns(http_subresource)
         @ui.expects(:confirm).with("Really send?").returns(true)
-        @ui.expects(:show_status_preview).with(status)
+        @ui.expects(:show_status_preview).with(status_latin1)
         @ui.expects(:info).with("Sent status update.\n\n")
         @ui.expects(:show_tweets).with(internal_records)
-        @twitter.update(status)
+        @twitter.update(status_latin1)
+      end
+    else
+      it "encodes status in UTF-8 (String does not support encoding)" do
+        CharacterEncoding.forget_guess
+        tmp_kcode('NONE') do
+          tmp_env(:LANG => 'ISO-8859-1') do
+            status_utf8, status_latin1 = "r\xc3\xa9sum\xc3\xa9", "r\xe9sum\xe9"
+            twitter_records, internal_records = create_rest_api_status_records({
+              :from_user  => @username,
+              :status     => status_utf8
+            })
+            @oauth.expects(:request_signer)
+            http_subresource = mock
+            http_subresource.expects(:post).
+              with({ :status => status_utf8 }).
+              returns(twitter_records[0].to_json)
+            @rest_api.expects(:[]).
+              with("statuses/update.json").
+              returns(http_subresource)
+            @ui.expects(:confirm).with("Really send?").returns(true)
+            @ui.expects(:show_status_preview).with(status_latin1)
+            @ui.expects(:info).with("Sent status update.\n\n")
+            @ui.expects(:show_tweets).with(internal_records)
+            @twitter.update(status_latin1)
+          end
+        end
       end
+    end
 
-      should "post a status update via prompt, when positive confirmation" do
-        status = "wondering around"
+    describe "with URL shortening" do
+      before do
+        mock_url_shortener
+        stub_config(
+          :shorten_urls => {
+            :service_url    => "http://shorten.it/create",
+            :method         => "post",
+            :url_param_name => "url",
+            :xpath_selector => "//input[@id='short_url']/@value"
+          })
+      end
+
+      it "does not shorten URLs if not configured" do
+        stub_config
+        status = "reading http://www.w3.org/TR/1999/REC-xpath-19991116"
         twitter_records, internal_records = create_rest_api_status_records({
           :from_user  => @username,
           :status     => status
@@ -179,310 +346,142 @@ class ClientTest < UnitTestCase
         http_subresource.expects(:post).
           with({ :status => status }).
           returns(twitter_records[0].to_json)
+        @url_shortener.expects(:shorten).never
         @rest_api.expects(:[]).
           with("statuses/update.json").
           returns(http_subresource)
-        @ui.expects(:prompt).with("Status update").returns(status)
-        @ui.expects(:show_status_preview).with(status)
         @ui.expects(:confirm).with("Really send?").returns(true)
+        @ui.expects(:show_status_preview).with(status)
         @ui.expects(:info).with("Sent status update.\n\n")
         @ui.expects(:show_tweets).with(internal_records)
-        @twitter.update
-      end
-
-      should "cancel a status update via argument, when negative confirmation" do
-        status = "wondering around"
-        @rest_api.expects(:[]).never
-        @ui.expects(:show_status_preview).with(status)
-        @ui.expects(:confirm).with("Really send?").returns(false)
-        @ui.expects(:info).with("Cancelled.")
-        @ui.expects(:show_tweets).never
         @twitter.update(status)
       end
 
-      should "cancel a status update via prompt, when negative confirmation" do
-        status = "wondering around"
-        @rest_api.expects(:[]).never
-        @ui.expects(:prompt).with("Status update").returns(status)
-        @ui.expects(:show_status_preview).with(status)
-        @ui.expects(:confirm).with("Really send?").returns(false)
-        @ui.expects(:info).with("Cancelled.")
-        @ui.expects(:show_tweets).never
-        @twitter.update
-      end
-
-      should "cancel a status update via argument, when empty status" do
-        @rest_api.expects(:[]).never
-        @ui.expects(:prompt).with("Status update").returns("")
-        @ui.expects(:confirm).never
-        @ui.expects(:info).with("Cancelled.")
-        @ui.expects(:show_tweets).never
-        @twitter.update("")
-      end
-
-      should "cancel a status update via prompt, when empty status" do
-        @rest_api.expects(:[]).never
-        @ui.expects(:prompt).with("Status update").returns("")
-        @ui.expects(:confirm).never
-        @ui.expects(:info).with("Cancelled.")
-        @ui.expects(:show_tweets).never
-        @twitter.update
+      it "shortens HTTP and HTTPS URLs" do
+        long_urls = ["http://www.google.fi/search?q=ruby+nokogiri&ie=utf-8&oe=utf-8&aq=t&rls=org.mozilla:en-US:official&client=firefox-a", "https://twitter.com/#!/messages"]
+        long_status = long_urls.join(" and ")
+        short_urls = ["http://shorten.it/2k7i8", "http://shorten.it/2k7mk"]
+        shortened_status = short_urls.join(" and ")
+        twitter_records, internal_records = create_rest_api_status_records({
+          :from_user  => @username,
+          :status     => shortened_status
+        })
+        @oauth.expects(:request_signer)
+        http_subresource = mock
+        http_subresource.expects(:post).
+          with({ :status => shortened_status }).
+          returns(twitter_records[0].to_json)
+        @rest_api.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)
+        @ui.expects(:show_status_preview).with(shortened_status)
+        @ui.expects(:confirm).with("Really send?").returns(true)
+        @ui.expects(:info).with("Sent status update.\n\n")
+        @ui.expects(:show_tweets).with(internal_records)
+        @twitter.update(long_status)
       end
 
-      should "remove excess whitespace around a status update" do
-        whitespaced_status = "  oh, i was sloppy \t   "
-        stripped_status = "oh, i was sloppy"
+      it "discards 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, ""]
         twitter_records, internal_records = create_rest_api_status_records({
           :from_user  => @username,
-          :status     => stripped_status
+          :status     => status
         })
         @oauth.expects(:request_signer)
         http_subresource = mock
         http_subresource.expects(:post).
-          with({ :status => stripped_status }).
+          with({ :status => status }).
           returns(twitter_records[0].to_json)
         @rest_api.expects(:[]).
           with("statuses/update.json").
           returns(http_subresource)
-        @ui.expects(:show_status_preview).with(stripped_status)
+        @url_shortener.expects(:shorten).with(long_urls.first).returns(short_urls.first)
+        @url_shortener.expects(:shorten).with(long_urls.last).returns(short_urls.last)
+        @ui.expects(:show_status_preview).with(status)
         @ui.expects(:confirm).with("Really send?").returns(true)
         @ui.expects(:info).with("Sent status update.\n\n")
         @ui.expects(:show_tweets).with(internal_records)
-        @twitter.update(whitespaced_status)
+        @twitter.update(status)
       end
 
-      should "truncate a status update with too long argument and warn the user" do
-        truncated_status = "ab c" * 35  #  4 * 35 = 140
-        long_status = "#{truncated_status} dd"
+      it "reuses a shortened URL for duplicate long URLs" do
+        long_urls = ["http://www.w3.org/TR/1999/REC-xpath-19991116"] * 2
+        long_status = long_urls.join(" and ")
+        short_url = "http://shorten.it/2k7mk"
+        short_status = ([short_url] * 2).join(" and ")
         twitter_records, internal_records = create_rest_api_status_records({
           :from_user  => @username,
-          :status     => truncated_status
+          :status     => short_status
         })
         @oauth.expects(:request_signer)
         http_subresource = mock
         http_subresource.expects(:post).
-          with({ :status => truncated_status }).
+          with({ :status => short_status }).
           returns(twitter_records[0].to_json)
         @rest_api.expects(:[]).
           with("statuses/update.json").
           returns(http_subresource)
-        @ui.expects(:warn).with("Status will be truncated.")
-        @ui.expects(:show_status_preview).with(truncated_status)
+        @url_shortener.expects(:shorten).with(long_urls.first).returns(short_url)
+        @ui.expects(:show_status_preview).with(short_status)
         @ui.expects(:confirm).with("Really send?").returns(true)
         @ui.expects(:info).with("Sent status update.\n\n")
         @ui.expects(:show_tweets).with(internal_records)
         @twitter.update(long_status)
       end
 
-      if defined? Encoding
-        should "encode status in UTF-8 (String supports encoding)" do
-          status_utf8, status_latin1 = "résumé", "résumé".encode('ISO-8859-1')
-          twitter_records, internal_records = create_rest_api_status_records({
+      describe "in erroneous situations" do
+        before do
+          @url = "http://www.w3.org/TR/1999/REC-xpath-19991116"
+          @status = "skimming through #{@url}"
+          @twitter_records, @internal_records = create_rest_api_status_records({
             :from_user  => @username,
-            :status     => status_utf8
+            :status     => @status
           })
-          @oauth.expects(:request_signer)
-          http_subresource = mock
-          http_subresource.expects(:post).
-            with({ :status => status_utf8 }).
-            returns(twitter_records[0].to_json)
-          @rest_api.expects(:[]).
-            with("statuses/update.json").
-            returns(http_subresource)
-          @ui.expects(:confirm).with("Really send?").returns(true)
-          @ui.expects(:show_status_preview).with(status_latin1)
-          @ui.expects(:info).with("Sent status update.\n\n")
-          @ui.expects(:show_tweets).with(internal_records)
-          @twitter.update(status_latin1)
-        end
-      else
-        should "encode status in UTF-8 (String does not support encoding)" do
-          tmp_kcode('NONE') do
-            tmp_env(:LANG => 'ISO-8859-1') do
-              status_utf8, status_latin1 = "r\xc3\xa9sum\xc3\xa9", "r\xe9sum\xe9"
-              twitter_records, internal_records = create_rest_api_status_records({
-                :from_user  => @username,
-                :status     => status_utf8
-              })
-              @oauth.expects(:request_signer)
-              http_subresource = mock
-              http_subresource.expects(:post).
-                with({ :status => status_utf8 }).
-                returns(twitter_records[0].to_json)
-              @rest_api.expects(:[]).
-                with("statuses/update.json").
-                returns(http_subresource)
-              @ui.expects(:confirm).with("Really send?").returns(true)
-              @ui.expects(:show_status_preview).with(status_latin1)
-              @ui.expects(:info).with("Sent status update.\n\n")
-              @ui.expects(:show_tweets).with(internal_records)
-              @twitter.update(status_latin1)
-            end
-          end
-        end
-      end
-
-      context "with URL shortening" do
-        setup do
-          mock_url_shortener
-          stub_config(
-            :shorten_urls => {
-              :service_url    => "http://shorten.it/create",
-              :method         => "post",
-              :url_param_name => "url",
-              :xpath_selector => "//input[@id='short_url']/@value"
-            })
         end
 
-        should "not shorten URLs if not configured" do
-          stub_config
-          status = "reading http://www.w3.org/TR/1999/REC-xpath-19991116"
-          twitter_records, internal_records = create_rest_api_status_records({
-            :from_user  => @username,
-            :status     => status
-          })
-          @oauth.expects(:request_signer)
-          http_subresource = mock
-          http_subresource.expects(:post).
-            with({ :status => status }).
-            returns(twitter_records[0].to_json)
-          @url_shortener.expects(:shorten).never
-          @rest_api.expects(:[]).
-            with("statuses/update.json").
-            returns(http_subresource)
-          @ui.expects(:confirm).with("Really send?").returns(true)
-          @ui.expects(:show_status_preview).with(status)
-          @ui.expects(:info).with("Sent status update.\n\n")
-          @ui.expects(:show_tweets).with(internal_records)
-          @twitter.update(status)
-        end
-
-        should "shorten HTTP and HTTPS URLs" do
-          long_urls = ["http://www.google.fi/search?q=ruby+nokogiri&ie=utf-8&oe=utf-8&aq=t&rls=org.mozilla:en-US:official&client=firefox-a", "https://twitter.com/#!/messages"]
-          long_status = long_urls.join(" and ")
-          short_urls = ["http://shorten.it/2k7i8", "http://shorten.it/2k7mk"]
-          shortened_status = short_urls.join(" and ")
-          twitter_records, internal_records = create_rest_api_status_records({
-            :from_user  => @username,
-            :status     => shortened_status
-          })
-          @oauth.expects(:request_signer)
-          http_subresource = mock
-          http_subresource.expects(:post).
-            with({ :status => shortened_status }).
-            returns(twitter_records[0].to_json)
-          @rest_api.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)
-          @ui.expects(:show_status_preview).with(shortened_status)
-          @ui.expects(:confirm).with("Really send?").returns(true)
-          @ui.expects(:info).with("Sent status update.\n\n")
-          @ui.expects(:show_tweets).with(internal_records)
-          @twitter.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, ""]
-          twitter_records, internal_records = create_rest_api_status_records({
-            :from_user  => @username,
-            :status     => status
-          })
+        it "skips shortening URLs if required libraries are not found" do
+          Tweetwine::CLI.stubs(:url_shortener).raises(LoadError, 'gem not found')
           @oauth.expects(:request_signer)
           http_subresource = mock
           http_subresource.expects(:post).
-            with({ :status => status }).
-            returns(twitter_records[0].to_json)
+            with({ :status => @status }).
+            returns(@twitter_records[0].to_json)
           @rest_api.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)
-          @ui.expects(:show_status_preview).with(status)
+          @ui.expects(:warn)
+          @ui.expects(:show_status_preview).with(@status)
           @ui.expects(:confirm).with("Really send?").returns(true)
           @ui.expects(:info).with("Sent status update.\n\n")
-          @ui.expects(:show_tweets).with(internal_records)
-          @twitter.update(status)
+          @ui.expects(:show_tweets).with(@internal_records)
+          @twitter.update(@status)
         end
 
-        should "reuse a shortened URL for duplicate long URLs" do
-          long_urls = ["http://www.w3.org/TR/1999/REC-xpath-19991116"] * 2
-          long_status = long_urls.join(" and ")
-          short_url = "http://shorten.it/2k7mk"
-          short_status = ([short_url] * 2).join(" and ")
-          twitter_records, internal_records = create_rest_api_status_records({
-            :from_user  => @username,
-            :status     => short_status
-          })
+        it "skips shortening URLs upon connection error to the URL shortening service" do
           @oauth.expects(:request_signer)
           http_subresource = mock
           http_subresource.expects(:post).
-            with({ :status => short_status }).
-            returns(twitter_records[0].to_json)
+            with({ :status => @status }).
+            returns(@twitter_records[0].to_json)
           @rest_api.expects(:[]).
             with("statuses/update.json").
             returns(http_subresource)
-          @url_shortener.expects(:shorten).with(long_urls.first).returns(short_url)
-          @ui.expects(:show_status_preview).with(short_status)
+          @url_shortener.expects(:shorten).with(@url).raises(HttpError.new(404, "Not Found"))
+          @ui.expects(:warn)
+          @ui.expects(:show_status_preview).with(@status)
           @ui.expects(:confirm).with("Really send?").returns(true)
           @ui.expects(:info).with("Sent status update.\n\n")
-          @ui.expects(:show_tweets).with(internal_records)
-          @twitter.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}"
-            @twitter_records, @internal_records = create_rest_api_status_records({
-              :from_user  => @username,
-              :status     => @status
-            })
-          end
-
-          should "skip shortening URLs if required libraries are not found" do
-            Tweetwine::CLI.stubs(:url_shortener).raises(LoadError, 'gem not found')
-            @oauth.expects(:request_signer)
-            http_subresource = mock
-            http_subresource.expects(:post).
-              with({ :status => @status }).
-              returns(@twitter_records[0].to_json)
-            @rest_api.expects(:[]).
-              with("statuses/update.json").
-              returns(http_subresource)
-            @ui.expects(:warn)
-            @ui.expects(:show_status_preview).with(@status)
-            @ui.expects(:confirm).with("Really send?").returns(true)
-            @ui.expects(:info).with("Sent status update.\n\n")
-            @ui.expects(:show_tweets).with(@internal_records)
-            @twitter.update(@status)
-          end
-
-          should "skip shortening URLs upon connection error to the URL shortening service" do
-            @oauth.expects(:request_signer)
-            http_subresource = mock
-            http_subresource.expects(:post).
-              with({ :status => @status }).
-              returns(@twitter_records[0].to_json)
-            @rest_api.expects(:[]).
-              with("statuses/update.json").
-              returns(http_subresource)
-            @url_shortener.expects(:shorten).with(@url).raises(HttpError.new(404, "Not Found"))
-            @ui.expects(:warn)
-            @ui.expects(:show_status_preview).with(@status)
-            @ui.expects(:confirm).with("Really send?").returns(true)
-            @ui.expects(:info).with("Sent status update.\n\n")
-            @ui.expects(:show_tweets).with(@internal_records)
-            @twitter.update(@status)
-          end
+          @ui.expects(:show_tweets).with(@internal_records)
+          @twitter.update(@status)
         end
       end
     end
 
-    should "fetch friends" do
+    it "fetches friends" do
       twitter_records, internal_records = create_rest_api_user_records(
         {
           :from_user  => "zanzibar",
@@ -503,7 +502,7 @@ class ClientTest < UnitTestCase
       @twitter.friends
     end
 
-    should "fetch followers" do
+    it "fetches followers" do
       twitter_records, internal_records = create_rest_api_user_records(
         {
           :from_user  => "zanzibar",
@@ -522,63 +521,61 @@ class ClientTest < UnitTestCase
       @twitter.followers
     end
 
-    context "when searching tweets" do
-      should "raise exception if no search word is given" do
-        assert_raise(ArgumentError) { @twitter.search }
-      end
-
-      [
-        [nil,   "no operator"],
-        [:and,  "and operator"]
-      ].each do |op, desc|
-        should "search tweets matching all the given words with #{desc}" do
-          twitter_response, internal_records = create_search_api_status_records(
-            {
-              :from_user  => "zanzibar",
-              :status     => "@foo, wassup? #greets",
-              :to_user    => "foo"
-            },
-            {
-              :from_user  => "spoonman",
-              :status     => "@foo long time no see #greets",
-              :to_user    => "foo"
-            }
-          )
-          @search_api.expects(:[]).
-            with("search.json?q=%23greets%20%40foo&#{@search_api_query_str}").
-            returns(stub(:get => twitter_response.to_json))
-          @ui.expects(:show_tweets).with(internal_records)
-          @twitter.search(["#greets", "@foo"], op)
-        end
-      end
+    it "raises exception if no search word is given for searching tweets" do
+      assert_raises(ArgumentError) { @twitter.search }
+    end
 
-      should "search tweets matching any of the given words with or operator" do
+    [
+      [nil,   "no operator"],
+      [:and,  "and operator"]
+    ].each do |op, desc|
+      it "searches tweets matching all the given words with #{desc}" do
         twitter_response, internal_records = create_search_api_status_records(
           {
             :from_user  => "zanzibar",
-            :status     => "spinning around the floor #habits",
+            :status     => "@foo, wassup? #greets",
             :to_user    => "foo"
           },
           {
             :from_user  => "spoonman",
-            :status     => "drinking coffee, again #neurotic",
+            :status     => "@foo long time no see #greets",
             :to_user    => "foo"
           }
         )
         @search_api.expects(:[]).
-          with("search.json?q=%23habits%20OR%20%23neurotic&#{@search_api_query_str}").
+          with("search.json?q=%23greets%20%40foo&#{@search_api_query_str}").
           returns(stub(:get => twitter_response.to_json))
         @ui.expects(:show_tweets).with(internal_records)
-        @twitter.search(["#habits", "#neurotic"], :or)
+        @twitter.search(["#greets", "@foo"], op)
       end
     end
 
-    context "when authorization fails with HTTP 401 response" do
-      setup do
+    it "searches tweets matching any of the given words with or operator" do
+      twitter_response, internal_records = create_search_api_status_records(
+        {
+          :from_user  => "zanzibar",
+          :status     => "spinning around the floor #habits",
+          :to_user    => "foo"
+        },
+        {
+          :from_user  => "spoonman",
+          :status     => "drinking coffee, again #neurotic",
+          :to_user    => "foo"
+        }
+      )
+      @search_api.expects(:[]).
+        with("search.json?q=%23habits%20OR%20%23neurotic&#{@search_api_query_str}").
+        returns(stub(:get => twitter_response.to_json))
+      @ui.expects(:show_tweets).with(internal_records)
+      @twitter.search(["#habits", "#neurotic"], :or)
+    end
+
+    describe "when authorization fails with HTTP 401 response" do
+      before do
         mock_config
       end
 
-      should "authorize with OAuth and save config" do
+      it "authorizes with OAuth and save config" do
         twitter_records, internal_records = create_rest_api_status_records({
           :from_user  => @username,
           :status     => "wassup?"