tweetwine 0.2.5 → 0.2.7

data/test/fixtures/test_config.yaml

@@ -1,3 +1,4 @@
 username: foo
 password: bar
-colorize: false
+colors: false
+defopt: 78

data/test/io_test.rb

@@ -46,13 +46,14 @@ class IOTest < Test::Unit::TestCase
 
     context "with colorization disabled" do
       setup do
-        @io = IO.new({ :input => @input, :output => @output, :colorize => false })
+        @io = IO.new({ :input => @input, :output => @output, :colors => false })
       end
 
       should "output a record as user info when no status is given" do
-        record = { :user => "fooman" }
+        from_user = "fooman"
+        record = { :from_user => from_user }
         @output.expects(:puts).with(<<-END
-fooman
+#{from_user}
 
         END
         )
@@ -60,17 +61,17 @@ fooman
       end
 
       should "output a record as status info when status is given, without in-reply info" do
+        from_user = "fooman"
         status = "Hi, @barman! Lulz woo! #hellos"
         record = {
-          :user   => "fooman",
-          :status => {
-            :created_at => Time.at(1),
-            :text       => status
-          }
+          :from_user  => from_user,
+          :status     => status,
+          :created_at => Time.at(1),
+          :to_user    => nil
         }
         Util.expects(:humanize_time_diff).returns([2, "secs"])
         @output.expects(:puts).with(<<-END
-fooman, 2 secs ago:
+#{from_user}, 2 secs ago:
 #{status}
 
         END
@@ -79,18 +80,18 @@ fooman, 2 secs ago:
       end
 
       should "output a record as status info when status is given, with in-reply info" do
+        from_user = "barman"
+        to_user = "fooman"
         status = "Hi, @fooman! How are you doing?"
         record = {
-          :user   => "barman",
-          :status => {
-            :created_at   => Time.at(1),
-            :text         => status,
-            :in_reply_to  => "fooman"
-          }
+          :from_user  => from_user,
+          :status     => status,
+          :created_at => Time.at(1),
+          :to_user    => to_user
         }
         Util.expects(:humanize_time_diff).returns([2, "secs"])
         @output.expects(:puts).with(<<-END
-barman, in reply to fooman, 2 secs ago:
+#{from_user}, in reply to #{to_user}, 2 secs ago:
 #{status}
 
         END
@@ -112,13 +113,14 @@ barman, in reply to fooman, 2 secs ago:
 
     context "with colorization enabled" do
       setup do
-        @io = IO.new({ :input => @input, :output => @output, :colorize => true })
+        @io = IO.new({ :input => @input, :output => @output, :colors => true })
       end
 
       should "output a record as user info when no status is given" do
-        record = { :user => "fooman" }
+        from_user = "fooman"
+        record = { :from_user => from_user }
         @output.expects(:puts).with(<<-END
-\e[32mfooman\e[0m
+\e[32m#{from_user}\e[0m
 
         END
         )
@@ -126,17 +128,18 @@ barman, in reply to fooman, 2 secs ago:
       end
 
       should "output a record as status info when status is given, without in-reply info" do
+        from_user = "fooman"
+        status = "Wondering about the meaning of life."
         record = {
-          :user   => "fooman",
-          :status => {
-            :created_at => Time.at(1),
-            :text       => "Wondering the meaning of life."
-          }
+          :from_user  => from_user,
+          :status     => status,
+          :created_at => Time.at(1),
+          :to_user    => nil
         }
         Util.expects(:humanize_time_diff).returns([2, "secs"])
         @output.expects(:puts).with(<<-END
-\e[32mfooman\e[0m, 2 secs ago:
-Wondering the meaning of life.
+\e[32m#{from_user}\e[0m, 2 secs ago:
+#{status}
 
         END
         )
@@ -144,18 +147,18 @@ Wondering the meaning of life.
       end
 
       should "output a record as status info when status is given, with in-reply info" do
+        from_user = "barman"
+        to_user = "fooman"
         record = {
-          :user   => "barman",
-          :status => {
-            :created_at   => Time.at(1),
-            :text         => "Hi, @fooman! How are you doing? #hellos",
-            :in_reply_to  => "fooman"
-          }
+          :from_user  => from_user,
+          :status     => "@#{to_user}! How are you doing?",
+          :created_at => Time.at(1),
+          :to_user    => to_user
         }
         Util.expects(:humanize_time_diff).returns([2, "secs"])
         @output.expects(:puts).with(<<-END
-\e[32mbarman\e[0m, in reply to \e[32mfooman\e[0m, 2 secs ago:
-Hi, \e[33m@fooman\e[0m! How are you doing? \e[35m#hellos\e[0m
+\e[32m#{from_user}\e[0m, in reply to \e[32m#{to_user}\e[0m, 2 secs ago:
+\e[33m@#{to_user}\e[0m! How are you doing?
 
         END
         )
@@ -173,18 +176,38 @@ Hi, \e[33m@fooman\e[0m! How are you doing? \e[35m#hellos\e[0m
         @io.show_status_preview(status)
       end
 
+      should "highlight hashtags in a status" do
+        from_user = "barman"
+        hashtags = %w{#slang #beignHappy}
+        record = {
+          :from_user  => from_user,
+          :status     => "Lulz, so happy! #{hashtags[0]} #{hashtags[1]}",
+          :created_at => Time.at(1),
+          :to_user    => nil
+        }
+        Util.expects(:humanize_time_diff).returns([2, "secs"])
+        @output.expects(:puts).with(<<-END
+\e[32m#{from_user}\e[0m, 2 secs ago:
+Lulz, so happy! \e[35m#{hashtags[0]}\e[0m \e[35m#{hashtags[1]}\e[0m
+
+        END
+        )
+        @io.show_record(record)
+      end
+
       should "highlight HTTP and HTTPS URLs in a status" do
+        from_user = "barman"
+        links = %w{http://bit.ly/18rU_Vx http://is.gd/1qLk3 https://is.gd/2rLk4}
         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",
-          }
+          :from_user  => from_user,
+          :status     => "Three links: #{links[0]} #{links[1]} and #{links[2]}",
+          :created_at => Time.at(1),
+          :to_user    => nil
         }
         Util.expects(:humanize_time_diff).returns([2, "secs"])
         @output.expects(:puts).with(<<-END
-\e[32mbarman\e[0m, 2 secs ago:
-Three links: \e[36mhttp://bit.ly/18rU_Vx\e[0m \e[36mhttp://is.gd/1qLk3\e[0m and \e[36mhttps://is.gd/2rLk4\e[0m
+\e[32m#{from_user}\e[0m, 2 secs ago:
+Three links: \e[36m#{links[0]}\e[0m \e[36m#{links[1]}\e[0m and \e[36m#{links[2]}\e[0m
 
         END
         )
@@ -192,17 +215,18 @@ Three links: \e[36mhttp://bit.ly/18rU_Vx\e[0m \e[36mhttp://is.gd/1qLk3\e[0m and
       end
 
       should "highlight HTTP and HTTPS URLs in a status, even if duplicates" do
+        from_user = "barman"
+        link = "http://is.gd/1qLk3"
         record = {
-          :user   => "barman",
-          :status => {
-            :created_at   => Time.at(1),
-            :text         => "Duplicate links: http://is.gd/1qLk3 and http://is.gd/1qLk3",
-          }
+          :from_user  => from_user,
+          :status     => "Duplicate links: #{link} and #{link}",
+          :created_at => Time.at(1),
+          :to_user    => nil
         }
         Util.expects(:humanize_time_diff).returns([2, "secs"])
         @output.expects(:puts).with(<<-END
-\e[32mbarman\e[0m, 2 secs ago:
-Duplicate links: \e[36mhttp://is.gd/1qLk3\e[0m and \e[36mhttp://is.gd/1qLk3\e[0m
+\e[32m#{from_user}\e[0m, 2 secs ago:
+Duplicate links: \e[36m#{link}\e[0m and \e[36m#{link}\e[0m
 
         END
         )
@@ -210,17 +234,18 @@ Duplicate links: \e[36mhttp://is.gd/1qLk3\e[0m and \e[36mhttp://is.gd/1qLk3\e[0m
       end
 
       should "highlight usernames in a status" do
+        from_user = "barman"
+        users = %w{@fooman @barbaz @spoonman}
         record = {
-          :user   => "barman",
-          :status => {
-            :created_at   => Time.at(1),
-            :text         => "I salute you @fooman, @barbaz, and @spoonman!",
-          }
+          :from_user  => from_user,
+          :status     => "I salute you #{users[0]}, #{users[1]}, and #{users[2]}!",
+          :created_at => Time.at(1),
+          :to_user    => nil
         }
         Util.expects(:humanize_time_diff).returns([2, "secs"])
         @output.expects(:puts).with(<<-END
-\e[32mbarman\e[0m, 2 secs ago:
-I salute you \e[33m@fooman\e[0m, \e[33m@barbaz\e[0m, and \e[33m@spoonman\e[0m!
+\e[32m#{from_user}\e[0m, 2 secs ago:
+I salute you \e[33m#{users[0]}\e[0m, \e[33m#{users[1]}\e[0m, and \e[33m#{users[2]}\e[0m!
 
         END
         )
@@ -228,17 +253,19 @@ I salute you \e[33m@fooman\e[0m, \e[33m@barbaz\e[0m, and \e[33m@spoonman\e[0m!
       end
 
       should "not highlight email addresses as usernames in a status" do
+        from_user = "barman"
+        users = %w{@fooman @barbaz}
+        email = "barbaz@foo.net"
         record = {
-          :user   => "barman",
-          :status => {
-            :created_at   => Time.at(1),
-            :text         => "Hi, @fooman! You should notify @barbaz, barbaz@foo.net",
-          }
+          :from_user  => from_user,
+          :status     => "Hi, #{users[0]}! You should notify #{users[1]}, #{email}",
+          :created_at => Time.at(1),
+          :to_user    => nil
         }
         Util.expects(:humanize_time_diff).returns([2, "secs"])
         @output.expects(:puts).with(<<-END
-\e[32mbarman\e[0m, 2 secs ago:
-Hi, \e[33m@fooman\e[0m! You should notify \e[33m@barbaz\e[0m, barbaz@foo.net
+\e[32m#{from_user}\e[0m, 2 secs ago:
+Hi, \e[33m#{users[0]}\e[0m! You should notify \e[33m#{users[1]}\e[0m, #{email}
 
         END
         )

data/test/retrying_http_test.rb

@@ -0,0 +1,127 @@
+require "test_helper"
+require "rest_client"
+
+class Object
+  def sleep(timeout); end   # speed up tests
+end
+
+module Tweetwine
+module RetryingHttp
+
+class ClientTest < Test::Unit::TestCase
+  context "A Client instance" do
+    setup do
+      @io = mock()
+      @client = Client.new(@io)
+    end
+
+    should "wrap RestClient.get" do
+      RestClient.expects(:get).with("https://site.org")
+      @client.get("https://site.org")
+    end
+
+    should "wrap RestClient.post" do
+      RestClient.expects(:post).with("https://site.org", { :key => "value" })
+      @client.post("https://site.org", { :key => "value" })
+    end
+
+    should "raise HttpError for an invalid request" do
+      RestClient.expects(:get).with("https://charlie:42@authorization.org").raises(RestClient::Unauthorized)
+      assert_raise(HttpError) { @client.get("https://charlie:42@authorization.org") }
+    end
+
+    should "raise HttpError when connection cannot be established" do
+      RestClient.expects(:get).with("https://unreachable.org").raises(Errno::ECONNABORTED)
+      assert_raise(HttpError) { @client.get("https://unreachable.org") }
+    end
+
+    should "raise HttpError when host cannot be resolved" do
+      RestClient.expects(:get).with("https://unresolved.org").raises(SocketError)
+      assert_raise(HttpError) { @client.get("https://unresolved.org") }
+    end
+
+    should "retry connection upon connection reset" do
+      retrying_calls = sequence("Retrying Client calls")
+      RestClient.expects(:get).with("https://moderate.traffic.org").in_sequence(retrying_calls).raises(Errno::ECONNRESET)
+      RestClient.expects(:get).with("https://moderate.traffic.org").in_sequence(retrying_calls)
+      @io.expects(:warn).with("Could not connect -- retrying in 4 seconds")
+      @client.get("https://moderate.traffic.org")
+    end
+
+    should "retry connection a maximum of certain number of times" do
+      retrying_calls = sequence("Retrying Client calls")
+      io_calls = sequence("IO")
+      Client::MAX_RETRIES.times do
+        RestClient.expects(:get).with("https://unresponsive.org").in_sequence(retrying_calls).raises(Errno::ECONNRESET)
+      end
+      (Client::MAX_RETRIES - 1).times do
+        @io.expects(:warn).in_sequence(io_calls)
+      end
+      assert_raise(HttpError) { @client.get("https://unresponsive.org") }
+    end
+
+    should "return a resource with IO inherited from the client" do
+      resource = @client.as_resource("http://foo.bar")
+      assert_equal(@io, resource.io)
+    end
+  end
+end
+
+class ResourceTest < Test::Unit::TestCase
+  context "A Resource instance" do
+    setup do
+      @io = mock()
+      @wrapped = mock()
+      @resource = Resource.new(@wrapped)
+      @resource.io = @io
+    end
+
+    should "allow wrapping RestClient::Resource#get" do
+      @wrapped.expects(:get).with("https://site.org")
+      @resource.get("https://site.org")
+    end
+
+    should "allow wrapping RestClient::Resource#post" do
+      @wrapped.expects(:post).with("https://site.org", { :key => "value" })
+      @resource.post("https://site.org", { :key => "value" })
+    end
+
+    should "raise HttpError for an invalid request" do
+      @wrapped.expects(:get).raises(RestClient::Unauthorized)
+      assert_raise(HttpError) { @resource.get }
+    end
+
+    should "raise HttpError when connection cannot be established" do
+      @wrapped.expects(:get).raises(Errno::ECONNABORTED)
+      assert_raise(HttpError) { @resource.get }
+    end
+
+    should "raise HttpError when host cannot be resolved" do
+      @wrapped.expects(:get).raises(SocketError)
+      assert_raise(HttpError) { @resource.get }
+    end
+
+    should "retry connection upon connection reset" do
+      retrying_calls = sequence("Retrying Resource calls")
+      @wrapped.expects(:get).in_sequence(retrying_calls).raises(Errno::ECONNRESET)
+      @wrapped.expects(:get).in_sequence(retrying_calls)
+      @io.expects(:warn).with("Could not connect -- retrying in 4 seconds")
+      @resource.get
+    end
+
+    should "retry connection a maximum of certain number of times" do
+      retrying_calls = sequence("Retrying Resource calls")
+      io_calls = sequence("IO")
+      Resource::MAX_RETRIES.times do
+        @wrapped.expects(:get).in_sequence(retrying_calls).raises(Errno::ECONNRESET)
+      end
+      (Resource::MAX_RETRIES - 1).times do
+        @io.expects(:warn).in_sequence(io_calls)
+      end
+      assert_raise(HttpError) { @resource.get }
+    end
+  end
+end
+
+end
+end

data/test/startup_config_test.rb

@@ -9,21 +9,32 @@ class StartupConfigTest < Test::Unit::TestCase
     context "upon initialization" do
       should "require at least one supported command" do
         assert_raise(ArgumentError) { StartupConfig.new([]) }
-        assert_nothing_raised { StartupConfig.new([:default_action]) }
+        assert_nothing_raised { StartupConfig.new([:cmd], :cmd) }
+      end
+
+      should "require the default command to be a supported command" do
+        assert_raise(ArgumentError) { StartupConfig.new([:cmd_a], :cmd_b) }
+        assert_nothing_raised { StartupConfig.new([:cmd_a], :cmd_a) }
+      end
+
+      should "allow passing default options" do
+        opts = {:opt => "foo"}
+        config = StartupConfig.new([:cmd_a], :cmd_a, opts)
+        assert_equal opts, config.options
       end
     end
 
     context "at runtime" do
       setup do
-        @config = StartupConfig.new([:default_action, :another_action])
+        @config = StartupConfig.new([:default_action, :another_action], :default_action, {:defopt => 42})
       end
 
-      should "use the first supported command as a default command when given no command as a cmdline argument" do
+      should "use the default command when given no command as a cmdline argument" do
         @config.parse
         assert_equal :default_action, @config.command
       end
 
-      should "check that given command is supported" do
+      should "pass supported commands" do
         @config.parse(%w{default_action}) { |args| {} }
         assert_equal :default_action, @config.command
 
@@ -31,53 +42,67 @@ class StartupConfigTest < Test::Unit::TestCase
         assert_equal :another_action, @config.command
       end
 
-      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"}
+      should "raise ArgumentError if given command is not supported" do
+        assert_raise(ArgumentError) do
+          @config.parse(%w{unknown_action}) { |args| {} }
         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
+      context "when given cmdline args and no config file" do
         setup do
-          @config.parse([], TEST_CONFIG_FILE)
+          @cmd_args = %w{--opt bar --another_opt baz another_action left overs}
+          @config.parse(@cmd_args) do |args|
+            args.slice!(0..3)
+            {:defopt => 56, :nopt => "baz"}
+          end
         end
 
         should "have the parsed option defined" do
-          assert_equal false, @config.options[:colorize]
+          assert_equal "baz", @config.options[:nopt]
+        end
+
+        should "override default options with the options given as cmdline args" do
+          assert_equal 56, @config.options[:defopt]
+        end
+
+        should "parse cmdline args before the command" do
+          assert_equal({:defopt => 56, :nopt => "baz"}, @config.options)
+        end
+
+        should "identify the next argument after cmdline args as the command" do
+          assert_equal :another_action, @config.command
+        end
+
+        should "leave remaining args to be consumed by the command" do
+          assert_equal %w{left overs}, @cmd_args
         end
       end
 
-      context "when given cmdline args and no config file" do
+      context "when given no cmdline args and a config file" do
         setup do
-          @config.parse(%w{--opt foo}) do |args|
-            args.clear
-            {:opt => "foo"}
-          end
+          @config.parse([], TEST_CONFIG_FILE)
         end
 
         should "have the parsed option defined" do
-          assert_equal "foo", @config.options[:opt]
+          assert_equal false, @config.options[:colors]
+        end
+
+        should "override default options with the options given from the config file" do
+          assert_equal 78, @config.options[:defopt]
         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|
+          @config.parse(%w{--colors}, TEST_CONFIG_FILE) do |args|
             args.clear
-            {:colorize => true}
+            {:defopt => 56, :colors => true}
           end
         end
 
         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]
+          assert_equal true, @config.options[:colors]
+          assert_equal 56, @config.options[:defopt]
         end
       end
     end

data/test/test_helper.rb

@@ -5,33 +5,48 @@ require "mocha"
 
 module Tweetwine
   module TestHelpers
-    def create_test_statuses(*gen_records)
-      status_records = gen_records.map do |gen_record|
+    def create_test_twitter_status_records_from_rest_api(*internal_records)
+      twitter_records = internal_records.map do |internal_record|
         {
-          "user"                    => { "screen_name" => gen_record[:user] },
-          "created_at"              => gen_record[:status][:created_at],
-          "text"                    => gen_record[:status][:text],
-          "in_reply_to_screen_name" => gen_record[:status][:in_reply_to]
+          "user"                    => { "screen_name" => internal_record[:from_user] },
+          "created_at"              => internal_record[:created_at],
+          "text"                    => internal_record[:status],
+          "in_reply_to_screen_name" => internal_record[:to_user]
         }
       end
-      [status_records, gen_records]
+      [twitter_records, internal_records]
     end
 
-    def create_test_users(*gen_records)
-      user_records = gen_records.map do |gen_record|
-        user_record = { "screen_name" => gen_record[:user] }
-        if gen_record[:status]
-          user_record.merge!({
+    def create_test_twitter_user_records_from_rest_api(*internal_records)
+      twitter_records = internal_records.map do |internal_record|
+        twitter_record = { "screen_name" => internal_record[:from_user] }
+        if internal_record[:status]
+          twitter_record.merge!({
             "status" => {
-              "created_at"              => gen_record[:status][:created_at],
-              "text"                    => gen_record[:status][:text],
-              "in_reply_to_screen_name" => gen_record[:status][:in_reply_to],
+              "created_at"              => internal_record[:created_at],
+              "text"                    => internal_record[:status],
+              "in_reply_to_screen_name" => internal_record[:to_user],
             }
           })
         end
-        user_record
+        twitter_record
       end
-      [user_records, gen_records]
+      [twitter_records, internal_records]
+    end
+
+    def create_test_twitter_records_from_search_api(*internal_records)
+      twitter_search_records = internal_records.map do |internal_record|
+        {
+          "from_user"   => internal_record[:from_user],
+          "created_at"  => internal_record[:created_at],
+          "text"        => internal_record[:status],
+          "to_user"     => internal_record[:to_user]
+        }
+      end
+      twitter_records = {
+        "results" => twitter_search_records
+      }
+      [twitter_records, internal_records]
     end
   end
 end