tuomas-tweetwine 0.2.2 → 0.2.4

data/test/io_test.rb

@@ -3,12 +3,13 @@ require "test_helper"
 module Tweetwine
 
 class IOTest < Test::Unit::TestCase
-  context "An IO" do
+  context "An IO instance" do
     setup do
       @input = mock()
       @output = mock()
       @io = IO.new({ :input => @input, :output => @output })
     end
+
     should "output prompt and return input as trimmed" do
       @output.expects(:print).with("The answer: ")
       @input.expects(:gets).returns("  42 ")
@@ -42,193 +43,189 @@ class IOTest < Test::Unit::TestCase
       @input.expects(:gets).returns("")
       assert_equal false, @io.confirm("Fire nukes?")
     end
-  end
 
-  context "An IO, with colorization disabled" do
-    setup do
-      @input = mock()
-      @output = mock()
-      @io = IO.new({ :input => @input, :output => @output, :colorize => false })
-    end
+    context "with colorization disabled" do
+      setup do
+        @io = IO.new({ :input => @input, :output => @output, :colorize => false })
+      end
 
-    should "output a record as user info when no status is given" do
-      record = { :user => "fooman" }
-      @output.expects(:puts).with(<<-END
+      should "output a record as user info when no status is given" do
+        record = { :user => "fooman" }
+        @output.expects(:puts).with(<<-END
 fooman
 
-      END
-      )
-      @io.show_record(record)
-    end
-
-    should "output a record as status info when status is given, without in-reply info" do
-      status = "Hi, @barman! Lulz woo! #hellos"
-      record = {
-        :user   => "fooman",
-        :status => {
-          :created_at => Time.at(1),
-          :text       => status
+        END
+        )
+        @io.show_record(record)
+      end
+
+      should "output a record as status info when status is given, without in-reply info" do
+        status = "Hi, @barman! Lulz woo! #hellos"
+        record = {
+          :user   => "fooman",
+          :status => {
+            :created_at => Time.at(1),
+            :text       => status
+          }
         }
-      }
-      Util.expects(:humanize_time_diff).returns([2, "secs"])
-      @output.expects(:puts).with(<<-END
+        Util.expects(:humanize_time_diff).returns([2, "secs"])
+        @output.expects(:puts).with(<<-END
 fooman, 2 secs ago:
 #{status}
 
-      END
-      )
-      @io.show_record(record)
-    end
-
-    should "output a record as status info when status is given, with in-reply info" do
-      status = "Hi, @fooman! How are you doing?"
-      record = {
-        :user   => "barman",
-        :status => {
-          :created_at   => Time.at(1),
-          :text         => status,
-          :in_reply_to  => "fooman"
+        END
+        )
+        @io.show_record(record)
+      end
+
+      should "output a record as status info when status is given, with in-reply info" do
+        status = "Hi, @fooman! How are you doing?"
+        record = {
+          :user   => "barman",
+          :status => {
+            :created_at   => Time.at(1),
+            :text         => status,
+            :in_reply_to  => "fooman"
+          }
         }
-      }
-      Util.expects(:humanize_time_diff).returns([2, "secs"])
-      @output.expects(:puts).with(<<-END
+        Util.expects(:humanize_time_diff).returns([2, "secs"])
+        @output.expects(:puts).with(<<-END
 barman, in reply to fooman, 2 secs ago:
 #{status}
 
-      END
-      )
-      @io.show_record(record)
-    end
+        END
+        )
+        @io.show_record(record)
+      end
 
-    should "output a preview of a status" do
-      status = "@nick, check http://bit.ly/18rU_Vx"
-      @output.expects(:puts).with(<<-END
+      should "output a preview of a status" do
+        status = "@nick, check http://bit.ly/18rU_Vx"
+        @output.expects(:puts).with(<<-END
 
 #{status}
 
-      END
-      )
-      @io.show_status_preview(status)
+        END
+        )
+        @io.show_status_preview(status)
+      end
     end
-  end
 
-  context "An IO, with colorization enabled" do
-    setup do
-      @input = mock()
-      @output = mock()
-      @io = IO.new({ :input => @input, :output => @output, :colorize => true })
-    end
+    context "with colorization enabled" do
+      setup do
+        @io = IO.new({ :input => @input, :output => @output, :colorize => true })
+      end
 
-    should "output a record as user info when no status is given" do
-      record = { :user => "fooman" }
-      @output.expects(:puts).with(<<-END
+      should "output a record as user info when no status is given" do
+        record = { :user => "fooman" }
+        @output.expects(:puts).with(<<-END
 \033[32mfooman\033[0m
 
-      END
-      )
-      @io.show_record(record)
-    end
-
-    should "output a record as status info when status is given, without in-reply info" do
-      record = {
-        :user   => "fooman",
-        :status => {
-          :created_at => Time.at(1),
-          :text       => "Wondering the meaning of life."
+        END
+        )
+        @io.show_record(record)
+      end
+
+      should "output a record as status info when status is given, without in-reply info" do
+        record = {
+          :user   => "fooman",
+          :status => {
+            :created_at => Time.at(1),
+            :text       => "Wondering the meaning of life."
+          }
         }
-      }
-      Util.expects(:humanize_time_diff).returns([2, "secs"])
-      @output.expects(:puts).with(<<-END
+        Util.expects(:humanize_time_diff).returns([2, "secs"])
+        @output.expects(:puts).with(<<-END
 \033[32mfooman\033[0m, 2 secs ago:
 Wondering the meaning of life.
 
-      END
-      )
-      @io.show_record(record)
-    end
-
-    should "output a record as status info when status is given, with in-reply info" do
-      record = {
-        :user   => "barman",
-        :status => {
-          :created_at   => Time.at(1),
-          :text         => "Hi, @fooman! How are you doing? #hellos",
-          :in_reply_to  => "fooman"
+        END
+        )
+        @io.show_record(record)
+      end
+
+      should "output a record as status info when status is given, with in-reply info" do
+        record = {
+          :user   => "barman",
+          :status => {
+            :created_at   => Time.at(1),
+            :text         => "Hi, @fooman! How are you doing? #hellos",
+            :in_reply_to  => "fooman"
+          }
         }
-      }
-      Util.expects(:humanize_time_diff).returns([2, "secs"])
-      @output.expects(:puts).with(<<-END
+        Util.expects(:humanize_time_diff).returns([2, "secs"])
+        @output.expects(:puts).with(<<-END
 \033[32mbarman\033[0m, in reply to \033[32mfooman\033[0m, 2 secs ago:
 Hi, \033[33m@fooman\033[0m! How are you doing? \033[35m#hellos\033[0m
 
-      END
-      )
-      @io.show_record(record)
-    end
+        END
+        )
+        @io.show_record(record)
+      end
 
-    should "output a preview of a status" do
-      status = "@nick, check http://bit.ly/18rU_Vx"
-      @output.expects(:puts).with(<<-END
+      should "output a preview of a status" do
+        status = "@nick, check http://bit.ly/18rU_Vx"
+        @output.expects(:puts).with(<<-END
 
 \033[33m@nick\033[0m, check \033[36mhttp://bit.ly/18rU_Vx\033[0m
 
-      END
-      )
-      @io.show_status_preview(status)
-    end
-
-    should "highlight HTTP and HTTPS URLs in a status" do
-      record = {
-        :user   => "barman",
-        :status => {
-          :created_at   => Time.at(1),
-          :text         => "Three links: http://bit.ly/18rU_Vx http://is.gd/1qLk3 and https://is.gd/2rLk4",
+        END
+        )
+        @io.show_status_preview(status)
+      end
+
+      should "highlight HTTP and HTTPS URLs in a status" do
+        record = {
+          :user   => "barman",
+          :status => {
+            :created_at   => Time.at(1),
+            :text         => "Three links: http://bit.ly/18rU_Vx http://is.gd/1qLk3 and https://is.gd/2rLk4",
+          }
         }
-      }
-      Util.expects(:humanize_time_diff).returns([2, "secs"])
-      @output.expects(:puts).with(<<-END
+        Util.expects(:humanize_time_diff).returns([2, "secs"])
+        @output.expects(:puts).with(<<-END
 \033[32mbarman\033[0m, 2 secs ago:
 Three links: \033[36mhttp://bit.ly/18rU_Vx\033[0m \033[36mhttp://is.gd/1qLk3\033[0m and \033[36mhttps://is.gd/2rLk4\033[0m
 
-      END
-      )
-      @io.show_record(record)
-    end
-
-    should "highlight HTTP and HTTPS URLs in a status, even if duplicates" do
-      record = {
-        :user   => "barman",
-        :status => {
-          :created_at   => Time.at(1),
-          :text         => "Duplicate links: http://is.gd/1qLk3 and http://is.gd/1qLk3",
+        END
+        )
+        @io.show_record(record)
+      end
+
+      should "highlight HTTP and HTTPS URLs in a status, even if duplicates" do
+        record = {
+          :user   => "barman",
+          :status => {
+            :created_at   => Time.at(1),
+            :text         => "Duplicate links: http://is.gd/1qLk3 and http://is.gd/1qLk3",
+          }
         }
-      }
-      Util.expects(:humanize_time_diff).returns([2, "secs"])
-      @output.expects(:puts).with(<<-END
+        Util.expects(:humanize_time_diff).returns([2, "secs"])
+        @output.expects(:puts).with(<<-END
 \033[32mbarman\033[0m, 2 secs ago:
 Duplicate links: \033[36mhttp://is.gd/1qLk3\033[0m and \033[36mhttp://is.gd/1qLk3\033[0m
 
-      END
-      )
-      @io.show_record(record)
-    end
-
-    should "highlight usernames in a status" do
-      record = {
-        :user   => "barman",
-        :status => {
-          :created_at   => Time.at(1),
-          :text         => "I salute you @fooman, @barbaz, and @spoonman!",
+        END
+        )
+        @io.show_record(record)
+      end
+
+      should "highlight usernames in a status" do
+        record = {
+          :user   => "barman",
+          :status => {
+            :created_at   => Time.at(1),
+            :text         => "I salute you @fooman, @barbaz, and @spoonman!",
+          }
         }
-      }
-      Util.expects(:humanize_time_diff).returns([2, "secs"])
-      @output.expects(:puts).with(<<-END
+        Util.expects(:humanize_time_diff).returns([2, "secs"])
+        @output.expects(:puts).with(<<-END
 \033[32mbarman\033[0m, 2 secs ago:
 I salute you \033[33m@fooman\033[0m, \033[33m@barbaz\033[0m, and \033[33m@spoonman\033[0m!
 
-      END
-      )
-      @io.show_record(record)
+        END
+        )
+        @io.show_record(record)
+      end
     end
   end
 

data/test/options_test.rb

@@ -3,7 +3,7 @@ require "test_helper"
 module Tweetwine
 
 class OptionsTest < Test::Unit::TestCase
-  context "Options" do
+  context "An Options instance" do
     should "get the value corresponding to a key or nil (the default value)" do
       assert_equal "alpha", Options.new({:a => "alpha"})[:a]
       assert_equal nil, Options.new({})[:a]

data/test/rest_client_wrapper_test.rb

@@ -1,29 +1,66 @@
 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 rest client wrapper" do
+  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) { RestClientWrapper.get("https://secret:agent@hushhush.net") }
+      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::ECONNRESET)
-      assert_raise(ClientError) { RestClientWrapper.get("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) { RestClientWrapper.get("http://unknown.net") }
+      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

data/test/startup_config_test.rb

@@ -5,78 +5,80 @@ module Tweetwine
 class StartupConfigTest < Test::Unit::TestCase
   TEST_CONFIG_FILE = File.dirname(__FILE__) << "/test_config.yaml"
 
-  context "To initialize a StartupConfig" do
-    should "require at least one supported command" do
-      assert_raise(ArgumentError) { StartupConfig.new([]) }
-      assert_nothing_raised { StartupConfig.new([:default_action]) }
-    end
-  end
-
-  context "An initialized StartupConfig" do
-    setup do
-      @config = StartupConfig.new([:default_action, :another_action])
+  context "A StartupConfig instance" do
+    context "upon initialization" do
+      should "require at least one supported command" do
+        assert_raise(ArgumentError) { StartupConfig.new([]) }
+        assert_nothing_raised { StartupConfig.new([:default_action]) }
+      end
     end
 
-    should "use the first supported command as a default command when given no command as a cmdline argument" do
-      @config.parse
-      assert_equal :default_action, @config.command
-    end
+    context "at runtime" do
+      setup do
+        @config = StartupConfig.new([:default_action, :another_action])
+      end
 
-    should "check that given command is supported" do
-      @config.parse(%w{default_action}) { |args| {} }
-      assert_equal :default_action, @config.command
+      should "use the first supported command as a default command when given no command as a cmdline argument" do
+        @config.parse
+        assert_equal :default_action, @config.command
+      end
 
-      @config.parse(%w{another_action}) { |args| {} }
-      assert_equal :another_action, @config.command
-    end
+      should "check that given command is supported" do
+        @config.parse(%w{default_action}) { |args| {} }
+        assert_equal :default_action, @config.command
 
-    should "parse cmdline args, command, and leftover args" do
-      @config.parse(%w{--opt foo another_action left overs}) do |args|
-         args.slice!(0..1)
-         {:opt => "foo"}
+        @config.parse(%w{another_action}) { |args| {} }
+        assert_equal :another_action, @config.command
       end
-      assert_equal({:opt => "foo"}, @config.options)
-      assert_equal :another_action, @config.command
-      assert_equal %w{left overs},  @config.args
-    end
 
-    context "when given no cmdline args and a config file" do
-      setup do
-        @config.parse([], TEST_CONFIG_FILE)
+      should "parse cmdline args, command, and leftover args" do
+        @config.parse(%w{--opt foo another_action left overs}) do |args|
+           args.slice!(0..1)
+           {:opt => "foo"}
+        end
+        assert_equal({:opt => "foo"}, @config.options)
+        assert_equal :another_action, @config.command
+        assert_equal %w{left overs},  @config.args
       end
 
-      should "have the parsed option defined" do
-        assert_equal false, @config.options[:colorize]
-      end
-    end
+      context "when given no cmdline args and a config file" do
+        setup do
+          @config.parse([], TEST_CONFIG_FILE)
+        end
 
-    context "when given cmdline args and no config file" do
-      setup do
-        @config.parse(%w{--opt foo}) do |args|
-          args.clear
-          {:opt => "foo"}
+        should "have the parsed option defined" do
+          assert_equal false, @config.options[:colorize]
         end
       end
 
-      should "have the parsed option defined" do
-        assert_equal "foo", @config.options[:opt]
-      end
-    end
+      context "when given cmdline args and no config file" do
+        setup do
+          @config.parse(%w{--opt foo}) do |args|
+            args.clear
+            {:opt => "foo"}
+          end
+        end
 
-    context "when given an option both as a cmdline option and in a config file" do
-      setup do
-        @config.parse(%w{--colorize}, TEST_CONFIG_FILE) do |args|
-          args.clear
-          {:colorize => true}
+        should "have the parsed option defined" do
+          assert_equal "foo", @config.options[:opt]
         end
       end
 
-      should "the command line option should override the config file option" do
-        assert_equal true, @config.options[:colorize]
-      end
+      context "when given an option both as a cmdline option and in a config file" do
+        setup do
+          @config.parse(%w{--colorize}, TEST_CONFIG_FILE) do |args|
+            args.clear
+            {:colorize => true}
+          end
+        end
 
-      should "have nil for an undefined option" do
-        assert_nil @config.options[:num_statuses]
+        should "the command line option should override the config file option" do
+          assert_equal true, @config.options[:colorize]
+        end
+
+        should "have nil for an undefined option" do
+          assert_nil @config.options[:num_statuses]
+        end
       end
     end
   end