tweetwine 0.2.4

data/test/io_test.rb

@@ -0,0 +1,265 @@
+require "test_helper"
+
+module Tweetwine
+
+class IOTest < Test::Unit::TestCase
+  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 ")
+      assert_equal "42", @io.prompt("The answer")
+    end
+
+    should "output info message" do
+      @output.expects(:puts).with("foo")
+      @io.info("foo")
+    end
+
+    should "output warning message" do
+      @output.expects(:puts).with("Warning: monkey patching ahead")
+      @io.warn("monkey patching ahead")
+    end
+
+    should "confirm action, with positive answer" do
+      @output.expects(:print).with("Fire nukes? [yN] ")
+      @input.expects(:gets).returns("y")
+      assert_equal true, @io.confirm("Fire nukes?")
+    end
+
+    should "confirm action, with negative answer" do
+      @output.expects(:print).with("Fire nukes? [yN] ")
+      @input.expects(:gets).returns("n")
+      assert_equal false, @io.confirm("Fire nukes?")
+    end
+
+    should "confirm action, with default answer" do
+      @output.expects(:print).with("Fire nukes? [yN] ")
+      @input.expects(:gets).returns("")
+      assert_equal false, @io.confirm("Fire nukes?")
+    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
+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
+          }
+        }
+        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"
+          }
+        }
+        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
+
+      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
+    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
+\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."
+          }
+        }
+        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"
+          }
+        }
+        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
+
+      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",
+          }
+        }
+        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",
+          }
+        }
+        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!",
+          }
+        }
+        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
+    end
+  end
+
+  context "Username regex" do
+    should "match a proper username reference" do
+      assert_full_match IO::USERNAME_REGEX, "@nick"
+      assert_full_match IO::USERNAME_REGEX, "@nick_man"
+    end
+
+    should "not match an inproper username reference" do
+      assert_no_full_match IO::USERNAME_REGEX, "@"
+      assert_no_full_match IO::USERNAME_REGEX, "nick"
+      assert_no_full_match IO::USERNAME_REGEX, "@nick-man"
+      assert_no_full_match IO::USERNAME_REGEX, " @nick"
+      assert_no_full_match IO::USERNAME_REGEX, "@nick "
+      assert_no_full_match IO::USERNAME_REGEX, " @nick "
+    end
+  end
+
+  context "Hashtag regex" do
+    should "match a proper hashtag reference" do
+      assert_full_match IO::HASHTAG_REGEX, "#mayhem"
+      assert_full_match IO::HASHTAG_REGEX, "#friday_mayhem"
+      assert_full_match IO::HASHTAG_REGEX, "#friday-mayhem"
+    end
+
+    should "not match an inproper hashtag reference" do
+      assert_no_full_match IO::USERNAME_REGEX, "#"
+      assert_no_full_match IO::USERNAME_REGEX, "mayhem"
+      assert_no_full_match IO::USERNAME_REGEX, " #mayhem"
+      assert_no_full_match IO::USERNAME_REGEX, "#mayhem "
+      assert_no_full_match IO::USERNAME_REGEX, " #mayhem "
+    end
+  end
+end
+
+end

data/test/options_test.rb

@@ -0,0 +1,43 @@
+require "test_helper"
+
+module Tweetwine
+
+class OptionsTest < Test::Unit::TestCase
+  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]
+    end
+
+    context "for requiring options" do
+      should "raise ArgumentError if there's no value for the required option (a value that is nil)" do
+        assert_equal "alpha", Options.new({:a => "alpha"}).require(:a)
+        assert_raise(ArgumentError) { Options.new({}).require(:a) }
+      end
+
+      should "indicate the required option upon failure" do
+        error = nil
+        begin
+          Options.new({}).require(:a)
+          flunk "should have raised ArgumentError"
+        rescue ArgumentError => e
+          error = e
+        end
+        assert_equal("Option a is required", e.to_s)
+      end
+
+      should "indicate the required option upon failure, with optional error source" do
+        error = nil
+        begin
+          Options.new({}, "test options").require(:a)
+          flunk "should have raised ArgumentError"
+        rescue ArgumentError => e
+          error = e
+        end
+        assert_equal("Option a is required for test options", e.to_s)
+      end
+    end
+  end
+end
+
+end

data/test/rest_client_wrapper_test.rb

@@ -0,0 +1,68 @@
+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

data/test/startup_config_test.rb

@@ -0,0 +1,87 @@
+require "test_helper"
+
+module Tweetwine
+
+class StartupConfigTest < Test::Unit::TestCase
+  TEST_CONFIG_FILE = File.dirname(__FILE__) << "/test_config.yaml"
+
+  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
+
+    context "at runtime" do
+      setup do
+        @config = StartupConfig.new([:default_action, :another_action])
+      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
+
+      should "check that given command is supported" do
+        @config.parse(%w{default_action}) { |args| {} }
+        assert_equal :default_action, @config.command
+
+        @config.parse(%w{another_action}) { |args| {} }
+        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"}
+        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)
+        end
+
+        should "have the parsed option defined" do
+          assert_equal false, @config.options[:colorize]
+        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
+
+        should "have the parsed option defined" do
+          assert_equal "foo", @config.options[:opt]
+        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}
+          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]
+        end
+      end
+    end
+  end
+end
+
+end

data/test/test_config.yaml

@@ -0,0 +1,3 @@
+username: foo
+password: bar
+colorize: false

data/test/test_helper.rb

@@ -0,0 +1,57 @@
+require "tweetwine"
+require "test/unit"
+require "shoulda"
+require "mocha"
+
+module Tweetwine
+  module TestHelpers
+    def create_test_statuses(*gen_records)
+      status_records = gen_records.map do |gen_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]
+        }
+      end
+      [status_records, gen_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!({
+            "status" => {
+              "created_at"              => gen_record[:status][:created_at],
+              "text"                    => gen_record[:status][:text],
+              "in_reply_to_screen_name" => gen_record[:status][:in_reply_to],
+            }
+          })
+        end
+        user_record
+      end
+      [user_records, gen_records]
+    end
+  end
+end
+
+Mocha::Configuration.prevent(:stubbing_non_existent_method)
+
+module Test
+  module Unit
+    class TestCase
+      include Tweetwine::TestHelpers
+
+      def assert_full_match(regex, str, msg = "")
+        match_data = regex.match(str)
+        assert(str == match_data.to_s, msg)
+      end
+
+      def assert_no_full_match(regex, str, msg = "")
+        match_data = regex.match(str)
+        assert(str != match_data.to_s, msg)
+      end
+    end
+  end
+end

data/test/url_shortener_test.rb

@@ -0,0 +1,161 @@
+require "test_helper"
+
+module Tweetwine
+
+class UrlShortenerTest < Test::Unit::TestCase
+  context "An UrlShortener instance" do
+    setup do
+      @rest_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,
+            {
+              :service_url      => nil,
+              :url_param_name   => "url",
+              :xpath_selector   => "//input[@id='short_url']/@value"
+            }
+          )
+        end
+      end
+
+      should "raise exception if URL parameter name is not given" do
+        assert_raise(ArgumentError) do
+          UrlShortener.new(
+            @rest_client,
+            {
+              :service_url      => "http://shorten.it/create",
+              :url_param_name   => nil,
+              :xpath_selector   => "//input[@id='short_url']/@value"
+            }
+          )
+        end
+      end
+
+      should "raise exception if XPath selector is not given" do
+        assert_raise(ArgumentError) do
+          UrlShortener.new(
+            @rest_client,
+            {
+              :service_url      => "http://shorten.it/create",
+              :url_param_name   => "url",
+              :xpath_selector   => nil
+            }
+          )
+        end
+      end
+
+      should "fallback to use GET method if not given explicitly" do
+        url_shortener = UrlShortener.new(
+          @rest_client,
+          {
+            :service_url      => "http://shorten.it/create",
+            :url_param_name   => "url",
+            :xpath_selector   => "//input[@id='short_url']/@value"
+          }
+        )
+        assert_equal(:get, url_shortener.instance_variable_get(:@method))
+      end
+    end
+
+    context "at runtime" do
+      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,
+            {
+              :method           => "get",
+              :service_url      => "http://shorten.it/create",
+              :url_param_name   => "url",
+              :xpath_selector   => "//input[@id='short_url']/@value"
+            }
+          )
+          @rest_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,
+            {
+              :method           => "get",
+              :service_url      => "http://shorten.it/create",
+              :url_param_name   => "url",
+              :extra_params     => {
+                :token => "xyz"
+              },
+              :xpath_selector   => "//input[@id='short_url']/@value"
+            }
+          )
+          @rest_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
+      end
+
+      context "configured for HTTP POST" do
+        should "use parameters as payload, with just the URL parameter" do
+          url_shortener = UrlShortener.new(
+            @rest_client,
+            {
+              :method           => "post",
+              :service_url      => "http://shorten.it/create",
+              :url_param_name   => "url",
+              :xpath_selector   => "//input[@id='short_url']/@value"
+            }
+          )
+          @rest_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,
+            {
+              :method           => "post",
+              :service_url      => "http://shorten.it/create",
+              :url_param_name   => "url",
+              :extra_params     => {
+                :token => "xyz"
+              },
+              :xpath_selector   => "//input[@id='short_url']/@value"
+            }
+          )
+          @rest_client.expects(:post) \
+              .with("http://shorten.it/create", {
+                :token => "xyz",
+                :url   => "http://www.ruby-doc.org/core/"
+              })
+          url_shortener.shorten("http://www.ruby-doc.org/core/")
+        end
+      end
+
+      context "in erroenous situations" do
+        should "raise ClientError upon connection error" do
+          url_shortener = UrlShortener.new(
+            @rest_client,
+            {
+              :method           => "post",
+              :service_url      => "http://shorten.it/create",
+              :url_param_name   => "url",
+              :xpath_selector   => "//input[@id='short_url']/@value"
+            }
+          )
+          @rest_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/") }
+        end
+      end
+    end
+  end
+end
+
+end