tweetwine 0.2.5 → 0.2.7

data/test/url_shortener_test.rb

@@ -5,14 +5,14 @@ module Tweetwine
 class UrlShortenerTest < Test::Unit::TestCase
   context "An UrlShortener instance" do
     setup do
-      @rest_client = mock()
+      @http_client = mock()
     end
 
     context "upon initialization" do
       should "raise exception if service URL is not given" do
         assert_raise(ArgumentError) do
           UrlShortener.new(
-            @rest_client,
+            @http_client,
             {
               :service_url      => nil,
               :url_param_name   => "url",
@@ -25,7 +25,7 @@ class UrlShortenerTest < Test::Unit::TestCase
       should "raise exception if URL parameter name is not given" do
         assert_raise(ArgumentError) do
           UrlShortener.new(
-            @rest_client,
+            @http_client,
             {
               :service_url      => "http://shorten.it/create",
               :url_param_name   => nil,
@@ -38,7 +38,7 @@ class UrlShortenerTest < Test::Unit::TestCase
       should "raise exception if XPath selector is not given" do
         assert_raise(ArgumentError) do
           UrlShortener.new(
-            @rest_client,
+            @http_client,
             {
               :service_url      => "http://shorten.it/create",
               :url_param_name   => "url",
@@ -50,7 +50,7 @@ class UrlShortenerTest < Test::Unit::TestCase
 
       should "fallback to use GET method if not given explicitly" do
         url_shortener = UrlShortener.new(
-          @rest_client,
+          @http_client,
           {
             :service_url      => "http://shorten.it/create",
             :url_param_name   => "url",
@@ -65,7 +65,7 @@ class UrlShortenerTest < Test::Unit::TestCase
       context "configured for HTTP GET" do
         should "use parameters as URL query parameters, with just the URL parameter" do
           url_shortener = UrlShortener.new(
-            @rest_client,
+            @http_client,
             {
               :method           => "get",
               :service_url      => "http://shorten.it/create",
@@ -73,14 +73,14 @@ class UrlShortenerTest < Test::Unit::TestCase
               :xpath_selector   => "//input[@id='short_url']/@value"
             }
           )
-          @rest_client.expects(:get) \
+          @http_client.expects(:get) \
               .with("http://shorten.it/create?url=http://www.ruby-doc.org/core/")
           url_shortener.shorten("http://www.ruby-doc.org/core/")
         end
 
         should "use parameters as URL query parameters, with additional extra parameters" do
           url_shortener = UrlShortener.new(
-            @rest_client,
+            @http_client,
             {
               :method           => "get",
               :service_url      => "http://shorten.it/create",
@@ -91,7 +91,7 @@ class UrlShortenerTest < Test::Unit::TestCase
               :xpath_selector   => "//input[@id='short_url']/@value"
             }
           )
-          @rest_client.expects(:get) \
+          @http_client.expects(:get) \
               .with("http://shorten.it/create?token=xyz&url=http://www.ruby-doc.org/core/")
           url_shortener.shorten("http://www.ruby-doc.org/core/")
         end
@@ -100,7 +100,7 @@ class UrlShortenerTest < Test::Unit::TestCase
       context "configured for HTTP POST" do
         should "use parameters as payload, with just the URL parameter" do
           url_shortener = UrlShortener.new(
-            @rest_client,
+            @http_client,
             {
               :method           => "post",
               :service_url      => "http://shorten.it/create",
@@ -108,14 +108,14 @@ class UrlShortenerTest < Test::Unit::TestCase
               :xpath_selector   => "//input[@id='short_url']/@value"
             }
           )
-          @rest_client.expects(:post) \
+          @http_client.expects(:post) \
               .with("http://shorten.it/create", {:url => "http://www.ruby-doc.org/core/"})
           url_shortener.shorten("http://www.ruby-doc.org/core/")
         end
 
         should "use parameters as payload, with additional extra parameters" do
           url_shortener = UrlShortener.new(
-            @rest_client,
+            @http_client,
             {
               :method           => "post",
               :service_url      => "http://shorten.it/create",
@@ -126,7 +126,7 @@ class UrlShortenerTest < Test::Unit::TestCase
               :xpath_selector   => "//input[@id='short_url']/@value"
             }
           )
-          @rest_client.expects(:post) \
+          @http_client.expects(:post) \
               .with("http://shorten.it/create", {
                 :token => "xyz",
                 :url   => "http://www.ruby-doc.org/core/"
@@ -136,9 +136,9 @@ class UrlShortenerTest < Test::Unit::TestCase
       end
 
       context "in erroenous situations" do
-        should "raise ClientError upon connection error" do
+        should "raise HttpError upon connection error" do
           url_shortener = UrlShortener.new(
-            @rest_client,
+            @http_client,
             {
               :method           => "post",
               :service_url      => "http://shorten.it/create",
@@ -146,12 +146,12 @@ class UrlShortenerTest < Test::Unit::TestCase
               :xpath_selector   => "//input[@id='short_url']/@value"
             }
           )
-          @rest_client.expects(:post) \
+          @http_client.expects(:post) \
               .with("http://shorten.it/create", {
                 :url   => "http://www.ruby-doc.org/core/"
               }) \
-              .raises(ClientError, "connection error")
-          assert_raise(ClientError) { url_shortener.shorten("http://www.ruby-doc.org/core/") }
+              .raises(HttpError, "connection error")
+          assert_raise(HttpError) { url_shortener.shorten("http://www.ruby-doc.org/core/") }
         end
       end
     end

data/test/util_test.rb

@@ -4,76 +4,104 @@ require "time"
 module Tweetwine
 
 class UtilTest < Test::Unit::TestCase
-  should "humanize time difference" do
-    assert_equal [1,  "sec"],   Util.humanize_time_diff(Time.parse("2009-01-01 00:00:59").to_s, Time.parse("2009-01-01 00:01:00"))
-    assert_equal [0,  "sec"],   Util.humanize_time_diff(Time.parse("2009-01-01 01:00:00").to_s, Time.parse("2009-01-01 01:00:00"))
-    assert_equal [1,  "sec"],   Util.humanize_time_diff(Time.parse("2009-01-01 01:00:00").to_s, Time.parse("2009-01-01 01:00:01"))
-    assert_equal [59, "sec"],   Util.humanize_time_diff(Time.parse("2009-01-01 01:00:00").to_s, Time.parse("2009-01-01 01:00:59"))
-    assert_equal [59, "min"],   Util.humanize_time_diff(Time.parse("2009-01-01 01:00").to_s, Time.parse("2009-01-01 01:59"))
-    assert_equal [59, "min"],   Util.humanize_time_diff(Time.parse("2009-01-01 01:00:30").to_s, Time.parse("2009-01-01 01:59:00"))
-    assert_equal [57, "min"],   Util.humanize_time_diff(Time.parse("2009-01-01 01:01:00").to_s, Time.parse("2009-01-01 01:58:00"))
-    assert_equal [56, "min"],   Util.humanize_time_diff(Time.parse("2009-01-01 01:01:31").to_s, Time.parse("2009-01-01 01:58:00"))
-    assert_equal [57, "min"],   Util.humanize_time_diff(Time.parse("2009-01-01 01:01:00").to_s, Time.parse("2009-01-01 01:58:29"))
-    assert_equal [58, "min"],   Util.humanize_time_diff(Time.parse("2009-01-01 01:01:00").to_s, Time.parse("2009-01-01 01:58:30"))
-    assert_equal [1,  "hour"],  Util.humanize_time_diff(Time.parse("2009-01-01 01:00").to_s, Time.parse("2009-01-01 02:00"))
-    assert_equal [1,  "hour"],  Util.humanize_time_diff(Time.parse("2009-01-01 02:00").to_s, Time.parse("2009-01-01 01:00"))
-    assert_equal [2,  "hours"], Util.humanize_time_diff(Time.parse("2009-01-01 01:00").to_s, Time.parse("2009-01-01 03:00"))
-    assert_equal [1,  "day"],   Util.humanize_time_diff(Time.parse("2009-01-01 01:00").to_s, Time.parse("2009-01-02 03:00"))
-    assert_equal [2,  "days"],  Util.humanize_time_diff(Time.parse("2009-01-01 01:00").to_s, Time.parse("2009-01-03 03:00"))
+  context "for humanizing time differences" do
+    should "use second granularity for time differences smaller than a minute" do
+      assert_equal [1,  "sec"], Util.humanize_time_diff(Time.parse("2009-01-01 00:00:59").to_s, Time.parse("2009-01-01 00:01:00"))
+      assert_equal [0,  "sec"], Util.humanize_time_diff(Time.parse("2009-01-01 01:00:00").to_s, Time.parse("2009-01-01 01:00:00"))
+      assert_equal [1,  "sec"], Util.humanize_time_diff(Time.parse("2009-01-01 01:00:00").to_s, Time.parse("2009-01-01 01:00:01"))
+      assert_equal [59, "sec"], Util.humanize_time_diff(Time.parse("2009-01-01 01:00:00").to_s, Time.parse("2009-01-01 01:00:59"))
+    end
+
+    should "use minute granularity for time differences greater than a minute but smaller than an hour" do
+      assert_equal [59, "min"], Util.humanize_time_diff(Time.parse("2009-01-01 01:00").to_s, Time.parse("2009-01-01 01:59"))
+      assert_equal [59, "min"], Util.humanize_time_diff(Time.parse("2009-01-01 01:00:30").to_s, Time.parse("2009-01-01 01:59:00"))
+      assert_equal [57, "min"], Util.humanize_time_diff(Time.parse("2009-01-01 01:01:00").to_s, Time.parse("2009-01-01 01:58:00"))
+      assert_equal [56, "min"], Util.humanize_time_diff(Time.parse("2009-01-01 01:01:31").to_s, Time.parse("2009-01-01 01:58:00"))
+      assert_equal [57, "min"], Util.humanize_time_diff(Time.parse("2009-01-01 01:01:00").to_s, Time.parse("2009-01-01 01:58:29"))
+      assert_equal [58, "min"], Util.humanize_time_diff(Time.parse("2009-01-01 01:01:00").to_s, Time.parse("2009-01-01 01:58:30"))
+    end
+
+    should "use hour granularity for time differences greater than an hour but smaller than a day" do
+      assert_equal [1,  "hour"],  Util.humanize_time_diff(Time.parse("2009-01-01 01:00").to_s, Time.parse("2009-01-01 02:00"))
+      assert_equal [1,  "hour"],  Util.humanize_time_diff(Time.parse("2009-01-01 02:00").to_s, Time.parse("2009-01-01 01:00"))
+      assert_equal [2,  "hours"], Util.humanize_time_diff(Time.parse("2009-01-01 01:00").to_s, Time.parse("2009-01-01 03:00"))
+    end
+
+    should "use day granularity for time differences greater than a day" do
+      assert_equal [1,  "day"],  Util.humanize_time_diff(Time.parse("2009-01-01 01:00").to_s, Time.parse("2009-01-02 03:00"))
+      assert_equal [2,  "days"], Util.humanize_time_diff(Time.parse("2009-01-01 01:00").to_s, Time.parse("2009-01-03 03:00"))
+    end
   end
 
-  should "symbolize hash keys" do
-    given = {
-      "alpha"   => "A",
-      :beta     => "B",
-      "charlie" => "C",
-      "delta"   => {
-        "echelon" => "E",
-        "fox"     => "F"
+  context "for recursively symbolizing keys in a hash" do
+    should "symbolize hash keys correctly" do
+      given = {
+        "alpha"   => "A",
+        :beta     => "B",
+        "charlie" => "C",
+        "delta"   => {
+          "echelon" => "E",
+          "fox"     => "F"
+        }
       }
-    }
-    expected = {
-      :alpha    => "A",
-      :beta     => "B",
-      :charlie  => "C",
-      :delta    => {
-        :echelon => "E",
-        :fox     => "F"
+      expected = {
+        :alpha    => "A",
+        :beta     => "B",
+        :charlie  => "C",
+        :delta    => {
+          :echelon => "E",
+          :fox     => "F"
+        }
       }
-    }
-    assert_equal expected, Util.symbolize_hash_keys(given)
+      assert_equal expected, Util.symbolize_hash_keys(given)
+    end
   end
 
-  should "parse integers from strings, with minimum and default values, and naming parameter" do
-    assert_equal 6, Util.parse_int_gt("6", 8, 4, "ethical working hours per day")
-    assert_equal 8, Util.parse_int_gt(nil, 8, 4, "ethical working hours per day")
-    assert_equal 8, Util.parse_int_gt(false, 8, 4, "ethical working hours per day")
-    assert_raise(ArgumentError) { Util.parse_int_gt(3, 8, 4, "ethical working hours per day") }
+  context "for parsing integers from strings, with minimum and default values, and naming parameter" do
+    should "return an integer from its string presentation" do
+      assert_equal 6, Util.parse_int_gt("6", 8, 4, "ethical working hours per day")
+    end
+
+    should "return default value if the string parameter is falsy" do
+      assert_equal 8, Util.parse_int_gt(nil, 8, 4, "ethical working hours per day")
+      assert_equal 8, Util.parse_int_gt(false, 8, 4, "ethical working hours per day")
+    end
+
+    should "raise an error if the parsed value is less than the minimum parameter" do
+      assert_raise(ArgumentError) { Util.parse_int_gt(3, 8, 4, "ethical working hours per day") }
+      assert_raise(ArgumentError) { Util.parse_int_gt("3", 8, 4, "ethical working hours per day") }
+    end
   end
 
   context "for replacing the contents of a string with a regexp that uses group syntax" do
-    should "replace the contents by using the matching groups of the regexp" do
-      assert_equal "hello", Util.str_gsub_by_group("hello", /he(f)/) { |s| s.upcase }
-      assert_equal "", Util.str_gsub_by_group("", /.+([ai])/) { |s| s.upcase }
-      assert_equal "hello", Util.str_gsub_by_group("hello", /.+([ai])/) { |s| s.upcase }
+    should "replace the contents of the string by using a single matching group of the regexp" do
       assert_equal "hEllo", Util.str_gsub_by_group("hello", /.+(e)/) { |s| s.upcase }
       assert_equal "hEllO", Util.str_gsub_by_group("hello", /([aeio])/) { |s| s.upcase }
       assert_equal "hEEllOO", Util.str_gsub_by_group("hello", /([aeio])/) { |s| s.upcase * 2 }
+      assert_equal "hll", Util.str_gsub_by_group("hello", /([aeio])/) { |s| "" }
+      assert_equal "hell", Util.str_gsub_by_group("hello", /.+([io])/) { |s| "" }
+    end
+
+    should "replace the contents of the string by using multiple matching groups of the regexp" do
       assert_equal "hEllO", Util.str_gsub_by_group("hello", /([ae]).+([io])/) { |s| s.upcase }
       assert_equal "hXEXllXOX", Util.str_gsub_by_group("hello", /([ae]).+([io])/) { |s| "X" + s.upcase + "X" }
       assert_equal "hll", Util.str_gsub_by_group("hello", /.+([ae]).+([io])/) { |s| "" }
       assert_equal "hll", Util.str_gsub_by_group("hello", /([ae]).+([io])/) { |s| "" }
-      assert_equal "hll", Util.str_gsub_by_group("hello", /([aeio])/) { |s| "" }
-      assert_equal "hell", Util.str_gsub_by_group("hello", /.+([io])/) { |s| "" }
       assert_equal "hEllo", Util.str_gsub_by_group("hello", /^(a)|.+(e)/) { |s| s.upcase }
     end
 
-    should "replace the contents by using the whole match if there are no groups in the regexp" do
+    should "replace the contents of the string by using the whole regexp if there are no groups in the regexp an the regexp matches" do
       assert_equal "", Util.str_gsub_by_group("", /el/) { |s| s.upcase }
       assert_equal "hELlo", Util.str_gsub_by_group("hello", /el/) { |s| s.upcase }
     end
 
-    should "return a new string as the result" do
+    should "not change the contents of the string if the regexp does not match" do
+      assert_equal "", Util.str_gsub_by_group("", /.+([ai])/) { |s| s.upcase }
+      assert_equal "hello", Util.str_gsub_by_group("hello", /.+([ai])/) { |s| s.upcase }
+      assert_equal "hello", Util.str_gsub_by_group("hello", /he(f)/) { |s| s.upcase }
+    end
+
+    should "return a new string as the result, leaving the original string unmodified" do
       org_str = "hello"
       new_str = Util.str_gsub_by_group(org_str, /e/) { |s| s.upcase }
       assert_not_same new_str, org_str
@@ -81,6 +109,76 @@ class UtilTest < Test::Unit::TestCase
       assert_equal "hEllo", new_str
     end
   end
+
+  context "for percent-encoding strings" do
+    should "not encode safe characters" do
+      assert_equal "a", Util.percent_encode("a")
+      assert_equal "B", Util.percent_encode("B")
+      assert_equal "3", Util.percent_encode("3")
+      assert_equal ".", Util.percent_encode(".")
+      assert_equal "-", Util.percent_encode("-")
+      assert_equal "_", Util.percent_encode("_")
+    end
+
+    should "encode space character with precent-encoding, not with '+' character" do
+      assert_equal "%20", Util.percent_encode(" ")
+    end
+
+    should "encode unsafe characters that URI.encode leaves by default unencoded" do
+      assert_equal "&",   URI.encode("&")
+      assert_equal "%26", Util.percent_encode("&")
+      assert_equal "?",   URI.encode("?")
+      assert_equal "%3F", Util.percent_encode("?")
+      assert_equal "/",   URI.encode("/")
+      assert_equal "%2F", Util.percent_encode("/")
+      assert_equal ":",   URI.encode(":")
+      assert_equal "%3A", Util.percent_encode(":")
+      assert_equal ",",   URI.encode(",")
+      assert_equal "%2C", Util.percent_encode(",")
+    end
+  end
+
+  context "for traversing a hash with a path expression for finding a value" do
+    setup do
+      @inner_hash = {
+        :salmon => "slick"
+      }
+      @inner_hash.default = "no such element in inner hash"
+      @outer_hash = {
+        :simple => "beautiful",
+        :inner  => @inner_hash,
+        :fishy  => nil
+      }
+      @outer_hash.default = "no such element in outer hash"
+    end
+
+    should "support both a non-array and a single element array path for finding the value" do
+      assert_equal "beautiful", Util.find_hash_path(@outer_hash, :simple)
+      assert_equal "beautiful", Util.find_hash_path(@outer_hash, [:simple])
+    end
+
+    should "find a nested value with an array path" do
+      assert_equal "slick", Util.find_hash_path(@outer_hash, [:inner, :salmon])
+    end
+
+    should "return the default value of the hash if the value cannot be found" do
+      assert_equal @outer_hash.default, Util.find_hash_path(@outer_hash, :difficult)
+      assert_equal @inner_hash.default, Util.find_hash_path(@outer_hash, [:inner, :cucumber])
+      assert_equal @outer_hash.default, Util.find_hash_path(@outer_hash, [:fishy, :no_such])
+    end
+
+    should "return the default value of the hash if invalid path value" do
+      assert_equal @outer_hash.default, Util.find_hash_path(@outer_hash, nil)
+      assert_equal @outer_hash.default, Util.find_hash_path(@outer_hash, [:no_such, nil])
+      assert_equal @outer_hash.default, Util.find_hash_path(@outer_hash, [:simple, nil])
+      assert_equal @outer_hash.default, Util.find_hash_path(@outer_hash, [:inner, nil])
+      assert_equal @outer_hash.default, Util.find_hash_path(@outer_hash, [:inner, :salmon, nil])
+    end
+
+    should "return nil if nil hash value" do
+      assert_equal nil, Util.find_hash_path(nil, nil)
+    end
+  end
 end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: tweetwine
 version: !ruby/object:Gem::Version 
-  version: 0.2.5
+  version: 0.2.7
 platform: ruby
 authors: 
 - Tuomas Kareinen
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-14 00:00:00 +03:00
+date: 2009-12-22 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -39,23 +39,36 @@ files:
 - README.rdoc
 - bin/tweetwine
 - example/example_helper.rb
-- example/fixtures/statuses.json
-- example/show_latest_statuses_example.rb
+- example/fixtures/home.json
+- example/fixtures/mentions.json
+- example/fixtures/search.json
+- example/fixtures/update.json
+- example/fixtures/user.json
+- example/fixtures/users.json
+- example/search_statuses_example.rb
+- example/show_followers_example.rb
+- example/show_friends_example.rb
+- example/show_home_example.rb
+- example/show_mentions_example.rb
 - example/show_metadata_example.rb
+- example/show_user_example.rb
+- example/update_status_example.rb
+- lib/tweetwine/cli.rb
 - lib/tweetwine/client.rb
 - lib/tweetwine/io.rb
 - lib/tweetwine/meta.rb
 - lib/tweetwine/options.rb
-- lib/tweetwine/rest_client_wrapper.rb
+- lib/tweetwine/retrying_http.rb
 - lib/tweetwine/startup_config.rb
 - lib/tweetwine/url_shortener.rb
 - lib/tweetwine/util.rb
 - lib/tweetwine.rb
+- test/cli_test.rb
 - test/client_test.rb
 - test/fixtures/test_config.yaml
 - test/io_test.rb
 - test/options_test.rb
-- test/rest_client_wrapper_test.rb
+- test/retrying_http_test.rb
 - test/startup_config_test.rb
 - test/test_helper.rb
 - test/url_shortener_test.rb
@@ -67,7 +80,7 @@ licenses: []
 post_install_message: 
 rdoc_options: 
 - --title
-- tweetwine 0.2.5
+- tweetwine 0.2.7
 - --main
 - README.rdoc
 - --exclude

data/example/show_latest_statuses_example.rb

@@ -1,45 +0,0 @@
-require "example_helper"
-
-Feature "show the latest statuses" do
-  in_order_to "stay up-to-date"
-  as_a "user"
-  i_want_to "see the latest statuses"
-
-  INJECTION = 'FakeWeb.register_uri(:get, "https://foouser:barpwd@twitter.com/statuses/friends_timeline.json?count=20&page=1", :body => fixture("statuses.json"))'
-
-  Scenario "see the latest statuses with colorization disabled" do
-    When "application is launched with command 'home'" do
-      @status = launch_app("-a foouser:barpwd --no-colorize", INJECTION) do |pid, stdin, stdout|
-        @output = stdout.readlines
-      end
-    end
-
-    Then "the latest statuses are shown" do
-      @output[0].should == "pelit, 11 days ago:\n"
-      @output[1].should == "F1-kausi alkaa marraskuussa http://bit.ly/1qQwjQ\n"
-      @output[2].should == "\n"
-      @output[58].should == "radar, 15 days ago:\n"
-      @output[59].should == "Four short links: 29 September 2009 http://bit.ly/dYxay\n"
-      @output[60].should == "\n"
-      @status.exitstatus.should == 0
-    end
-  end
-
-  Scenario "see the latest statuses with colorization enabled" do
-    When "application is launched with command 'home'" do
-      @status = launch_app("-a foouser:barpwd --colorize", INJECTION) do |pid, stdin, stdout|
-        @output = stdout.readlines
-      end
-    end
-
-    Then "the latest statuses are shown" do
-      @output[0].should == "\e[32mpelit\e[0m, 11 days ago:\n"
-      @output[1].should == "F1-kausi alkaa marraskuussa \e[36mhttp://bit.ly/1qQwjQ\e[0m\n"
-      @output[2].should == "\n"
-      @output[58].should == "\e[32mradar\e[0m, 15 days ago:\n"
-      @output[59].should == "Four short links: 29 September 2009 \e[36mhttp://bit.ly/dYxay\e[0m\n"
-      @output[60].should == "\n"
-      @status.exitstatus.should == 0
-    end
-  end
-end

data/lib/tweetwine/rest_client_wrapper.rb

@@ -1,37 +0,0 @@
-require "rest_client"
-
-module Tweetwine
-  class ClientError < RuntimeError; end
-
-  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 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/test/rest_client_wrapper_test.rb

@@ -1,68 +0,0 @@
-require "test_helper"
-require "rest_client"
-
-class Object
-  def sleep(timeout); end   # speed up tests
-end
-
-module Tweetwine
-
-class RestClientWrapperTest < Test::Unit::TestCase
-  context "A RestClientWrapper instance" do
-    setup do
-      @io = mock()
-      @rest_client = RestClientWrapper.new(@io)
-    end
-
-    should "raise ClientError for an invalid request" do
-      RestClient.expects(:get) \
-                .with("https://secret:agent@hushhush.net") \
-                .raises(RestClient::Unauthorized)
-      assert_raise(ClientError) { @rest_client.get("https://secret:agent@hushhush.net") }
-    end
-
-    should "raise ClientError when connection cannot be established" do
-      RestClient.expects(:get) \
-                .with("http://www.invalid.net") \
-                .raises(Errno::ECONNABORTED)
-      assert_raise(ClientError) { @rest_client.get("http://www.invalid.net") }
-    end
-
-    should "raise ClientError when host cannot be resolved" do
-      RestClient.expects(:get) \
-                .with("http://unknown.net") \
-                .raises(SocketError)
-      assert_raise(ClientError) { @rest_client.get("http://unknown.net") }
-    end
-
-    should "retry connection upon connection reset" do
-      rest_client_calls = sequence("RestClient")
-      RestClient.expects(:get) \
-                .with("http://www.heavilyloaded.net") \
-                .in_sequence(rest_client_calls) \
-                .raises(Errno::ECONNRESET)
-      RestClient.expects(:get) \
-                .with("http://www.heavilyloaded.net") \
-                .in_sequence(rest_client_calls)
-      @io.expects(:warn).with("Could not connect -- retrying in 4 seconds")
-      @rest_client.get("http://www.heavilyloaded.net")
-    end
-
-    should "retry connection a maximum of certain number of times" do
-      rest_client_calls = sequence("RestClient")
-      io_calls = sequence("IO")
-      RestClientWrapper::MAX_RETRIES.times do
-        RestClient.expects(:get) \
-                  .with("http://www.heavilyloaded.net") \
-                  .in_sequence(rest_client_calls) \
-                  .raises(Errno::ECONNRESET)
-      end
-      (RestClientWrapper::MAX_RETRIES - 1).times do
-        @io.expects(:warn).in_sequence(io_calls)
-      end
-      assert_raise(ClientError) { @rest_client.get("http://www.heavilyloaded.net") }
-    end
-  end
-end
-
-end