tuomas-tweetwine 0.2.2 → 0.2.4

data/CHANGELOG.rdoc

@@ -1,3 +1,10 @@
+=== 0.2.4 released 2009-09-16
+
+* Retry connection upon connection reset, trying maximum of three times.
+* Display proper version info on Ruby 1.8 when using option "-v".
+* Minor code cleanups.
+* Release 0.2.3 is skipped due to my error in tagging the wrong commit.
+
 === 0.2.2 released 2009-09-03
 
 * Highlight hashtags in statuses.

data/Rakefile

@@ -69,6 +69,7 @@ Rake::TestTask.new(:test) do |t|
   t.test_files = FileList["test/**/*_test.rb"]
   t.verbose = true
   t.warning = true
+  t.ruby_opts << "-rrubygems"
   t.libs << "test"
 end
 

data/bin/tweetwine

@@ -15,51 +15,63 @@ require "tweetwine"
 
 include Tweetwine
 
-begin
-  config = StartupConfig.new(Client::COMMANDS)
-  config.parse(ARGV, ENV["HOME"] + "/.tweetwine") do |args|
-    options = {}
-    begin
-      OptionParser.new do |opt|
-        opt.banner =<<-END
+cmd_parser = lambda do |args|
+  options = {}
+  begin
+    OptionParser.new do |opt|
+      opt.banner =<<-END
 Usage: tweetwine [options...] [command]
 
   Commands: #{Client::COMMANDS.join(", ")}
 
   Options:
 
-        END
-        opt.on("-a", "--auth USERNAME:PASSWORD", "Authentication") do |arg|
-          options[:username], options[:password] = arg.split(":", 2)
-        end
-        opt.on("-c", "--colorize", "Colorize output with ANSI escape codes") do
-          options[:colorize] = true
-        end
-        opt.on("-n", "--num N", Integer, "The number of statuses to fetch, defaults to #{Client::DEFAULT_NUM_STATUSES}") do |arg|
-          options[:num_statuses] = arg
-        end
-        opt.on("--no-url-shorten", "Do not shorten URLs for status update") do
-          options[:shorten_urls] = { :enable => false }
-        end
-        opt.on("-p", "--page N", Integer, "The page number of the statuses to fetch, defaults to #{Client::DEFAULT_PAGE_NUM}") do |arg|
-          options[:page_num] = arg
-        end
-        opt.on("-v", "--version", "Show version information and exit") do
-          puts "#{File.basename($0)} #{VERSION}"
-          exit(EXIT_VERSION)
-        end
-        opt.on_tail("-h", "--help", "Show this help message and exit") do
-          puts opt
-          exit(EXIT_HELP)
-        end
-      end.parse!(args)
-    rescue OptionParser::ParseError => e
-      raise ArgumentError, e.message
-    end
-    options
+      END
+      opt.on("-a", "--auth USERNAME:PASSWORD", "Authentication") do |arg|
+        options[:username], options[:password] = arg.split(":", 2)
+      end
+      opt.on("-c", "--colorize", "Colorize output with ANSI escape codes") do
+        options[:colorize] = true
+      end
+      opt.on("-n", "--num N", Integer, "The number of statuses to fetch, defaults to #{Client::DEFAULT_NUM_STATUSES}") do |arg|
+        options[:num_statuses] = arg
+      end
+      opt.on("--no-url-shorten", "Do not shorten URLs for status update") do
+        options[:shorten_urls] = { :enable => false }
+      end
+      opt.on("-p", "--page N", Integer, "The page number of the statuses to fetch, defaults to #{Client::DEFAULT_PAGE_NUM}") do |arg|
+        options[:page_num] = arg
+      end
+      opt.on("-v", "--version", "Show version information and exit") do
+        puts "#{File.basename($0)} #{Tweetwine::VERSION}"
+        exit(EXIT_VERSION)
+      end
+      opt.on_tail("-h", "--help", "Show this help message and exit") do
+        puts opt
+        exit(EXIT_HELP)
+      end
+    end.parse!(args)
+  rescue OptionParser::ParseError => e
+    raise ArgumentError, e.message
   end
-  io = Tweetwine::IO.new(config.options)
-  client = Client.new(io, config.options)
+  options
+end
+
+def create_dependencies(options)
+  io = Tweetwine::IO.new(options)
+  rest_client = RestClientWrapper.new(io)
+  url_shortener = lambda { |opts| UrlShortener.new(rest_client, opts) }
+  {
+    :io             => io,
+    :rest_client    => rest_client,
+    :url_shortener  => url_shortener
+  }
+end
+
+begin
+  config = StartupConfig.new(Client::COMMANDS)
+  config.parse(ARGV, ENV["HOME"] + "/.tweetwine", &cmd_parser)
+  client = Client.new(create_dependencies(config.options), config.options)
   client.send(config.command, *config.args)
 rescue ArgumentError, ClientError => e
   puts "Error: #{e.message}"

data/lib/tweetwine/client.rb

@@ -11,15 +11,16 @@ module Tweetwine
     DEFAULT_PAGE_NUM = 1
     MAX_STATUS_LENGTH = 140
 
-    def initialize(io, options)
-      @io = io
+    def initialize(dependencies, options)
+      @io = dependencies[:io]
+      @rest_client = dependencies[:rest_client]
       @username = options[:username].to_s
       raise ArgumentError, "No authentication data given" if @username.empty?
       @base_url = "https://#{@username}:#{options[:password]}@twitter.com/"
       @num_statuses = Util.parse_int_gt(options[:num_statuses], DEFAULT_NUM_STATUSES, 1, "number of statuses_to_show")
       @page_num = Util.parse_int_gt(options[:page_num], DEFAULT_PAGE_NUM, 1, "page number")
       @url_shortener = if options[:shorten_urls] && options[:shorten_urls][:enable]
-        UrlShortener.new(options[:shorten_urls])
+        dependencies[:url_shortener].call(options[:shorten_urls])
       else
         nil
       end
@@ -110,11 +111,11 @@ module Tweetwine
     end
 
     def get(body_url)
-      RestClientWrapper.get @base_url + body_url
+      @rest_client.get @base_url + body_url
     end
 
     def post(body_url, body)
-      RestClientWrapper.post @base_url + body_url, body
+      @rest_client.post @base_url + body_url, body
     end
 
     class StatusUpdateFactory

data/lib/tweetwine/io.rb

@@ -114,4 +114,4 @@ module Tweetwine
       "\033[#{color_code}m#{str}\033[0m"
     end
   end
-end
+end

data/lib/tweetwine/meta.rb

@@ -1,3 +1,3 @@
 module Tweetwine
-  VERSION = "0.2.2"
+  VERSION = "0.2.4"
 end

data/lib/tweetwine/rest_client_wrapper.rb

@@ -6,12 +6,32 @@ module Tweetwine
   class RestClientWrapper
     instance_methods.each { |m| undef_method m unless m =~ /(^__|^send$|^object_id$)/ }
 
+    MAX_RETRIES = 3
+    RETRY_BASE_WAIT_TIMEOUT = 4
+
+    def initialize(io)
+      @io = io
+    end
+
     protected
 
-    def self.method_missing(name, *args, &block)
-      RestClient.send(name, *args, &block)
-    rescue RestClient::Exception, SocketError, SystemCallError => e
-      raise ClientError, e.message
+    def method_missing(name, *args, &block)
+      tries = 0
+      begin
+        tries += 1
+        RestClient.send(name, *args, &block)
+      rescue Errno::ECONNRESET => e
+        if tries < MAX_RETRIES
+          timeout = RETRY_BASE_WAIT_TIMEOUT**tries
+          @io.warn("Could not connect -- retrying in #{timeout} seconds")
+          sleep timeout
+          retry
+        else
+          raise ClientError, e
+        end
+      rescue RestClient::Exception, SocketError, SystemCallError => e
+        raise ClientError, e
+      end
     end
   end
 end

data/lib/tweetwine/url_shortener.rb

@@ -1,6 +1,7 @@
 module Tweetwine
   class UrlShortener
-    def initialize(options)
+    def initialize(rest_client, options)
+      @rest_client = rest_client
       options = Options.new(options, "URL shortening")
       @method = (options[:method] || :get).to_sym
       @service_url = options.require :service_url
@@ -29,7 +30,7 @@ module Tweetwine
       else
         raise "Unrecognized HTTP request method"
       end
-      response = RestClientWrapper.send(@method, *rest)
+      response = @rest_client.send(@method, *rest)
       doc = Nokogiri::HTML(response)
       doc.xpath(@xpath_selector).first.to_s
     end

data/lib/tweetwine/util.rb

@@ -49,4 +49,4 @@ module Tweetwine
       unit
     end
   end
-end
+end

data/test/client_test.rb

@@ -6,323 +6,182 @@ Mocha::Configuration.allow(:stubbing_non_existent_method)
 module Tweetwine
 
 class ClientTest < Test::Unit::TestCase
-  context "Upon initialization, a client" do
+  context "A client instance" do
     setup do
       @io = mock()
+      @rest_client = mock()
+      @url_shortener = mock()
+      url_shortener = lambda { |options| @url_shortener }
+      @deps = {
+        :io             => @io,
+        :rest_client    => @rest_client,
+        :url_shortener  => url_shortener
+      }
     end
 
-    should "raise exception when no authentication data is given" do
-      assert_raise(ArgumentError) { Client.new(@io, {}) }
-      assert_raise(ArgumentError) { Client.new(@io, { :password => "bar" }) }
-      assert_raise(ArgumentError) { Client.new(@io, { :username => "", :password => "bar" }) }
-      assert_nothing_raised { Client.new(@io, { :username => "foo", :password => "bar" }) }
-    end
-
-    should "use default number of statuses if not configured otherwise" do
-      @client = Client.new(@io, { :username => "foo", :password => "bar" })
-      assert_equal Client::DEFAULT_NUM_STATUSES, @client.num_statuses
-    end
-
-    should "use configured number of statuses if in allowed range" do
-      @client = Client.new(@io, { :username => "foo", :password => "bar", :num_statuses => 12 })
-      assert_equal 12, @client.num_statuses
-    end
-
-    should "raise an exception for configured number of statuses if not in allowed range" do
-      assert_raise(ArgumentError) { Client.new(@io, { :username => "foo", :password => "bar", :num_statuses => 0 }) }
-    end
-
-    should "use default page number if not configured otherwise" do
-      @client = Client.new(@io, { :username => "foo", :password => "bar" })
-      assert_equal Client::DEFAULT_PAGE_NUM, @client.page_num
-    end
+    context "upon initialization" do
+      should "raise exception when no authentication data is given" do
+        assert_raise(ArgumentError) { Client.new(@deps, {}) }
+        assert_raise(ArgumentError) { Client.new(@deps, { :password => "bar" }) }
+        assert_raise(ArgumentError) { Client.new(@deps, { :username => "", :password => "bar" }) }
+        assert_nothing_raised { Client.new(@deps, { :username => "foo", :password => "bar" }) }
+      end
 
-    should "use configured page number if in allowed range" do
-      @client = Client.new(@io, { :username => "foo", :password => "bar", :page_num => 12 })
-      assert_equal 12, @client.page_num
-    end
+      should "use default number of statuses if not configured otherwise" do
+        @client = Client.new(@deps, { :username => "foo", :password => "bar" })
+        assert_equal Client::DEFAULT_NUM_STATUSES, @client.num_statuses
+      end
 
-    should "raise an exception for configured page number if not in allowed range" do
-      assert_raise(ArgumentError) { Client.new(@io, { :username => "foo", :password => "bar", :page_num => 0 }) }
-    end
-  end
+      should "use configured number of statuses if in allowed range" do
+        @client = Client.new(@deps, { :username => "foo", :password => "bar", :num_statuses => 12 })
+        assert_equal 12, @client.num_statuses
+      end
 
-  context "At runtime, a client" do
-    setup do
-      @io = mock()
-      @username = "spiky"
-      @password = "lullaby"
-      @client = Client.new(@io, { :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}"
-    end
+      should "raise an exception for configured number of statuses if not in allowed range" do
+        assert_raise(ArgumentError) { Client.new(@deps, { :username => "foo", :password => "bar", :num_statuses => 0 }) }
+      end
 
-    should "fetch friends' statuses (home view)" do
-      status_records, gen_records = create_test_statuses(
-        {
-          :user => "zanzibar",
-          :status => {
-            :created_at   => Time.at(1).to_s,
-            :text         => "wassup?",
-            :in_reply_to  => nil
-          }
-        },
-        {
-          :user => "lulzwoo",
-          :status => {
-            :created_at   => Time.at(1).to_s,
-            :text         => "nuttin'",
-            :in_reply_to  => nil
-          }
-        }
-      )
-      RestClientWrapper.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])
-      @client.home
-    end
+      should "use default page number if not configured otherwise" do
+        @client = Client.new(@deps, { :username => "foo", :password => "bar" })
+        assert_equal Client::DEFAULT_PAGE_NUM, @client.page_num
+      end
 
-    should "fetch mentions" do
-      status_records, gen_records = create_test_statuses(
-        {
-          :user => "zanzibar",
-          :status => {
-            :created_at   => Time.at(1).to_s,
-            :text         => "wassup, @#{@username}?",
-            :in_reply_to  => @username
-          }
-        },
-        {
-          :user => "lulzwoo",
-          :status => {
-            :created_at   => Time.at(1).to_s,
-            :text         => "@#{@username}, doing nuttin'",
-            :in_reply_to  => @username
-          }
-        }
-      )
-      RestClientWrapper.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])
-      @client.mentions
-    end
+      should "use configured page number if in allowed range" do
+        @client = Client.new(@deps, { :username => "foo", :password => "bar", :page_num => 12 })
+        assert_equal 12, @client.page_num
+      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(
-        {
-          :user => user,
-          :status => {
-            :created_at   => Time.at(1).to_s,
-            :text         => "wassup?",
-            :in_reply_to  => nil
-          }
-        }
-      )
-      RestClientWrapper.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)
+      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
     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(
-        {
-          :user => @username,
-          :status => {
-            :created_at   => Time.at(1).to_s,
-            :text         => "wassup?",
-            :in_reply_to  => nil
-          }
-        }
-      )
-      RestClientWrapper.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])
-      @client.user
-    end
+    context "at runtime" do
+      setup do
+        @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}"
+      end
 
-    context "for posting status updates" do
-      should "post a status update via argument, when positive confirmation" do
-        status = "wondering around"
+      should "fetch friends' statuses (home view)" do
         status_records, gen_records = create_test_statuses(
           {
-            :user => @username,
+            :user => "zanzibar",
             :status => {
               :created_at   => Time.at(1).to_s,
-              :text         => status,
+              :text         => "wassup?",
+              :in_reply_to  => nil
+            }
+          },
+          {
+            :user => "lulzwoo",
+            :status => {
+              :created_at   => Time.at(1).to_s,
+              :text         => "nuttin'",
               :in_reply_to  => nil
             }
           }
         )
-        RestClientWrapper.expects(:post) \
-            .with("#{@base_url}/statuses/update.json", {:status => status}) \
-            .returns(status_records[0].to_json)
-        @io.expects(:confirm).with("Really send?").returns(true)
-        @io.expects(:show_status_preview).with(status)
-        @io.expects(:info).with("Sent status update.\n\n")
+        @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])
-        @client.update(status)
+        @io.expects(:show_record).with(gen_records[1])
+        @client.home
       end
 
-      should "post a status update via prompt, when positive confirmation" do
-        status = "wondering around"
+      should "fetch mentions" do
         status_records, gen_records = create_test_statuses(
-          { :user => @username,
+          {
+            :user => "zanzibar",
             :status => {
               :created_at   => Time.at(1).to_s,
-              :text         => status,
-              :in_reply_to  => nil
+              :text         => "wassup, @#{@username}?",
+              :in_reply_to  => @username
+            }
+          },
+          {
+            :user => "lulzwoo",
+            :status => {
+              :created_at   => Time.at(1).to_s,
+              :text         => "@#{@username}, doing nuttin'",
+              :in_reply_to  => @username
             }
           }
         )
-        RestClientWrapper.expects(:post) \
-            .with("#{@base_url}/statuses/update.json", {:status => status}) \
-            .returns(status_records[0].to_json)
-        @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")
+        @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])
-        @client.update
-      end
-
-      should "cancel a status update via argument, when negative confirmation" do
-        status = "wondering around"
-        RestClientWrapper.expects(:post).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)
-      end
-
-      should "cancel a status update via prompt, when negative confirmation" do
-        status = "wondering around"
-        RestClientWrapper.expects(:post).never
-        @io.expects(:prompt).with("Status update").returns(status)
-        @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
-      end
-
-      should "cancel a status update via argument, when empty status" do
-        RestClientWrapper.expects(:post).never
-        @io.expects(:confirm).never
-        @io.expects(:info).with("Cancelled.")
-        @io.expects(:show_record).never
-        @client.update("")
+        @io.expects(:show_record).with(gen_records[1])
+        @client.mentions
       end
 
-      should "cancel a status update via prompt, when empty status" do
-        RestClientWrapper.expects(:post).never
-        @io.expects(:prompt).with("Status update").returns("")
-        @io.expects(:confirm).never
-        @io.expects(:info).with("Cancelled.")
-        @io.expects(:show_record).never
-        @client.update
-      end
-
-      should "remove excess whitespace around a status update" do
-        whitespaced_status = "  oh, i was sloppy \t   "
-        stripped_status = "oh, i was sloppy"
+      should "fetch a specific user's statuses, when the user identified by given argument" do
+        user = "spoonman"
         status_records, gen_records = create_test_statuses(
-          { :user => @username,
+          {
+            :user => user,
             :status => {
               :created_at   => Time.at(1).to_s,
-              :text         => stripped_status,
+              :text         => "wassup?",
               :in_reply_to  => nil
             }
           }
         )
-        RestClientWrapper.expects(:post) \
-            .with("#{@base_url}/statuses/update.json", {:status => stripped_status}) \
-            .returns(status_records[0].to_json)
-        @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")
+        @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.update(whitespaced_status)
+        @client.user(user)
       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"
+      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(
-          { :user => @username,
+          {
+            :user => @username,
             :status => {
               :created_at   => Time.at(1).to_s,
-              :text         => truncated_status,
+              :text         => "wassup?",
               :in_reply_to  => nil
             }
           }
         )
-        RestClientWrapper.expects(:post) \
-            .with("#{@base_url}/statuses/update.json", {:status => truncated_status}) \
-            .returns(status_records[0].to_json)
-        @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")
+        @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])
-        @client.update(long_status)
+        @client.user
       end
 
-      context "with URL shortening enabled" do
-        setup do
-          @client = Client.new(@io, {
-            :username => @username,
-            :password => @password,
-            :shorten_urls => {
-              :enable         => true,
-              :service_url    => "http://shorten.it/create",
-              :method         => "post",
-              :url_param_name => "url",
-              :xpath_selector => "//input[@id='short_url']/@value"
-            }
-          })
-          @url_shortener = @client.instance_variable_get(:@url_shortener)
-        end
-
-        should "shorten URLs, avoiding truncation with long 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", "http://www.w3.org/TR/1999/REC-xpath-19991116"]
-          long_status = long_urls.join(" and ")
-          short_urls = ["http://shorten.it/2k7i8", "http://shorten.it/2k7mk"]
-          shortened_status = short_urls.join(" and ")
+      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(
-            { :user => @username,
+            {
+              :user => @username,
               :status => {
                 :created_at   => Time.at(1).to_s,
-                :text         => shortened_status,
+                :text         => status,
                 :in_reply_to  => nil
               }
             }
           )
-          RestClientWrapper.expects(:post) \
-              .with("#{@base_url}/statuses/update.json", {:status => shortened_status}) \
+          @rest_client.expects(:post) \
+              .with("#{@base_url}/statuses/update.json", {:status => status}) \
               .returns(status_records[0].to_json)
-          @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(:show_status_preview).with(status)
           @io.expects(:info).with("Sent status update.\n\n")
           @io.expects(:show_record).with(gen_records[0])
-          @client.update(long_status)
+          @client.update(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, ""]
+        should "post a status update via prompt, when positive confirmation" do
+          status = "wondering around"
           status_records, gen_records = create_test_statuses(
             { :user => @username,
               :status => {
@@ -332,134 +191,283 @@ class ClientTest < Test::Unit::TestCase
               }
             }
           )
-          RestClientWrapper.expects(:post) \
+          @rest_client.expects(:post) \
               .with("#{@base_url}/statuses/update.json", {:status => status}) \
               .returns(status_records[0].to_json)
-          @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(: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])
+          @client.update
+        end
+
+        should "cancel a status update via argument, when negative confirmation" do
+          status = "wondering around"
+          @rest_client.expects(:post).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)
         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 ")
+        should "cancel a status update via prompt, when negative confirmation" do
+          status = "wondering around"
+          @rest_client.expects(:post).never
+          @io.expects(:prompt).with("Status update").returns(status)
+          @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
+        end
+
+        should "cancel a status update via argument, when empty status" do
+          @rest_client.expects(:post).never
+          @io.expects(:confirm).never
+          @io.expects(:info).with("Cancelled.")
+          @io.expects(:show_record).never
+          @client.update("")
+        end
+
+        should "cancel a status update via prompt, when empty status" do
+          @rest_client.expects(:post).never
+          @io.expects(:prompt).with("Status update").returns("")
+          @io.expects(:confirm).never
+          @io.expects(:info).with("Cancelled.")
+          @io.expects(:show_record).never
+          @client.update
+        end
+
+        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         => short_status,
+                :text         => stripped_status,
                 :in_reply_to  => nil
               }
             }
           )
-          RestClientWrapper.expects(:post) \
-              .with("#{@base_url}/statuses/update.json", {:status => short_status}) \
+          @rest_client.expects(:post) \
+              .with("#{@base_url}/statuses/update.json", {:status => stripped_status}) \
               .returns(status_records[0].to_json)
-          @url_shortener.expects(:shorten).with(long_urls.first).returns(short_url)
-          @io.expects(:show_status_preview).with(short_status)
+          @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)
+        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
+              }
+            }
+          )
+          @rest_client.expects(:post) \
+              .with("#{@base_url}/statuses/update.json", {:status => truncated_status}) \
+              .returns(status_records[0].to_json)
+          @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)
         end
 
-        context "in erroneous situations" do
+        context "with URL shortening enabled" do
           setup do
-            @url = "http://www.w3.org/TR/1999/REC-xpath-19991116"
-            @status = "skimming through #{@url}"
-            @status_records, @gen_records = create_test_statuses(
+            @client = Client.new(@deps, {
+              :username => @username,
+              :password => @password,
+              :shorten_urls => {
+                :enable         => true,
+                :service_url    => "http://shorten.it/create",
+                :method         => "post",
+                :url_param_name => "url",
+                :xpath_selector => "//input[@id='short_url']/@value"
+              }
+            })
+          end
+
+          should "shorten URLs, avoiding truncation with long 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", "http://www.w3.org/TR/1999/REC-xpath-19991116"]
+            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         => @status,
+                  :text         => shortened_status,
                   :in_reply_to  => nil
                 }
               }
             )
+            @rest_client.expects(:post) \
+                .with("#{@base_url}/statuses/update.json", {:status => shortened_status}) \
+                .returns(status_records[0].to_json)
+            @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)
           end
 
-          should "skip shortening URLs if required libraries are not found" do
-            RestClientWrapper.expects(:post) \
-                .with("#{@base_url}/statuses/update.json", {:status => @status}) \
-                .returns(@status_records[0].to_json)
-            @url_shortener.expects(:shorten).with(@url).raises(LoadError, "gem not found")
-            @io.expects(:warn)
-            @io.expects(:show_status_preview).with(@status)
+          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
+                }
+              }
+            )
+            @rest_client.expects(:post) \
+                .with("#{@base_url}/statuses/update.json", {:status => status}) \
+                .returns(status_records[0].to_json)
+            @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(gen_records[0])
+            @client.update(status)
           end
 
-          should "skip shortening URLs upon connection error to the URL shortening service" do
-            RestClientWrapper.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")
-            @io.expects(:warn)
-            @io.expects(:show_status_preview).with(@status)
+          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 ")
+            status_records, gen_records = create_test_statuses(
+              { :user => @username,
+                :status => {
+                  :created_at   => Time.at(1).to_s,
+                  :text         => short_status,
+                  :in_reply_to  => nil
+                }
+              }
+            )
+            @rest_client.expects(:post) \
+                .with("#{@base_url}/statuses/update.json", {:status => short_status}) \
+                .returns(status_records[0].to_json)
+            @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(@status)
+            @io.expects(:show_record).with(gen_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
+                  }
+                }
+              )
+            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)
+              @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)
+            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")
+              @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)
+            end
           end
         end
       end
-    end
 
-    should "fetch friends" do
-      user_records, gen_records = create_test_users(
-        {
-          :user => "zanzibar",
-          :status => {
-            :created_at   => Time.at(1).to_s,
-            :text         => "wassup, @foo?",
-            :in_reply_to  => "foo"
-          }
-        },
-        {
-          :user => "lulzwoo",
-          :status => {
-            :created_at   => Time.at(1).to_s,
-            :text         => "@foo, doing nuttin'",
-            :in_reply_to  => "foo"
+      should "fetch friends" do
+        user_records, gen_records = create_test_users(
+          {
+            :user => "zanzibar",
+            :status => {
+              :created_at   => Time.at(1).to_s,
+              :text         => "wassup, @foo?",
+              :in_reply_to  => "foo"
+            }
+          },
+          {
+            :user => "lulzwoo",
+            :status => {
+              :created_at   => Time.at(1).to_s,
+              :text         => "@foo, doing nuttin'",
+              :in_reply_to  => "foo"
+            }
           }
-        }
-      )
-      RestClientWrapper.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])
-      @client.friends
-    end
+        )
+        @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])
+        @client.friends
+      end
 
-    should "fetch followers" do
-      user_records, gen_records = create_test_users(
-        {
-          :user => "zanzibar",
-          :status => {
-            :created_at   => Time.at(1).to_s,
-            :text         => "wassup, @foo?",
-            :in_reply_to  => "foo"
+      should "fetch followers" do
+        user_records, gen_records = create_test_users(
+          {
+            :user => "zanzibar",
+            :status => {
+              :created_at   => Time.at(1).to_s,
+              :text         => "wassup, @foo?",
+              :in_reply_to  => "foo"
+            }
+          },
+          {
+            :user => "lulzwoo"
           }
-        },
-        {
-          :user => "lulzwoo"
-        }
-      )
-      RestClientWrapper.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])
-      @client.followers
+        )
+        @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])
+        @client.followers
+      end
     end
   end
 end