tweetwine 0.3.2 → 0.4.0

data/test/example/show_user_example.rb

@@ -3,9 +3,9 @@
 require "example_helper"
 
 Feature "show user's tweets" do
-  in_order_to "to see what's going on with a specific user"
   as_a "authenticated user"
-  i_want_to "see that user's tweets"
+  i_want_to "see a specific user's tweets"
+  in_order_to "to know what the user has been doing"
 
   USER_URL = "https://api.twitter.com/1/statuses/user_timeline.json?count=20&page=1&screen_name=%s"
   USER_FIXTURE = fixture_file('user.json')
@@ -17,11 +17,7 @@ Feature "show user's tweets" do
     end
 
     Then "the application shows my tweets" do
-      @output[0].should == "jillv, in reply to chris, 9 hours ago:"
-      @output[1].should == "@chris wait me until the garden"
-      @output[2].should == ""
-      @output[3].should == "jillv, 3 days ago:"
-      @output[4].should == "so boring to wait"
+      should_output_tweets
     end
   end
 
@@ -32,11 +28,17 @@ Feature "show user's tweets" do
     end
 
     Then "the application shows the user's tweets" do
-      @output[0].should == "jillv, in reply to chris, 9 hours ago:"
-      @output[1].should == "@chris wait me until the garden"
-      @output[2].should == ""
-      @output[3].should == "jillv, 3 days ago:"
-      @output[4].should == "so boring to wait"
+      should_output_tweets
     end
   end
+
+  private
+
+  def should_output_tweets
+    @output[0].should == "jillv, in reply to chris, 9 hours ago:"
+    @output[1].should == "@chris wait me until the garden"
+    @output[2].should == ""
+    @output[3].should == "jillv, 3 days ago:"
+    @output[4].should == "so boring to wait"
+  end
 end

data/test/example/update_status_example.rb

@@ -4,9 +4,9 @@ require "example_helper"
 require "yaml"
 
 Feature "update my status (send new tweet)" do
-  in_order_to "tell something about me to the world"
   as_a "authenticated user"
   i_want_to "update my status"
+  in_order_to "tell something about me to the world"
 
   RUBYGEMS_FIXTURE = fixture_file('shorten_rubygems.html')
   RUBYGEMS_FULL_URL = 'http://rubygems.org/'
@@ -146,14 +146,14 @@ Feature "update my status (send new tweet)" do
       @shorten_rubygems_body = "#{SHORTEN_CONFIG[:url_param_name]}=#{RUBYGEMS_FULL_URL_ENC}"
       @shorten_rubylang_body = "#{SHORTEN_CONFIG[:url_param_name]}=#{RUBYLANG_FULL_URL_ENC}"
       stub_http_request(SHORTEN_METHOD, SHORTEN_CONFIG[:service_url]).
-          with(:body => @shorten_rubygems_body).
-          to_return(:body => RUBYGEMS_FIXTURE)
+        with(:body => @shorten_rubygems_body).
+        to_return(:body => RUBYGEMS_FIXTURE)
       stub_http_request(SHORTEN_METHOD, SHORTEN_CONFIG[:service_url]).
-          with(:body => @shorten_rubylang_body).
-          to_return(:body => RUBYLANG_FIXTURE)
+        with(:body => @shorten_rubylang_body).
+        to_return(:body => RUBYLANG_FIXTURE)
       stub_http_request(:post, UPDATE_URL).
-          with(:body => BODY_WITH_SHORT_URLS).
-          to_return(:body => UPDATE_FIXTURE_WITH_URLS)
+        with(:body => BODY_WITH_SHORT_URLS).
+        to_return(:body => UPDATE_FIXTURE_WITH_URLS)
       @output = start_cli %W{--no-colors update #{STATUS_WITH_FULL_URLS}}, %w{y}
     end
 
@@ -169,8 +169,8 @@ Feature "update my status (send new tweet)" do
   Scenario "disable URL shortening for status updates" do
     When "I have configured URL shortening, start the application with 'update' command with --no-url-shorten option, input status containing URLs, and confirm" do
       stub_http_request(:post, UPDATE_URL).
-          with(:body => BODY_WITH_SHORT_URLS).
-          to_return(:body => UPDATE_FIXTURE_WITH_URLS)
+        with(:body => BODY_WITH_SHORT_URLS).
+        to_return(:body => UPDATE_FIXTURE_WITH_URLS)
       @output = start_cli %W{--no-colors --no-url-shorten update #{STATUS_WITH_SHORT_URLS}}, %w{y}
     end
 

data/test/example/use_http_proxy_example.rb

@@ -3,13 +3,15 @@
 require "example_helper"
 
 Feature "using HTTP proxy" do
-  in_order_to "tweet behind an HTTP proxy"
   as_a "authenticated user"
-  i_want_to "tweet as before"
+  i_want_to "use HTTP proxy"
+  in_order_to "tweet behind a firewall"
+
+  HOME_URL = "https://api.twitter.com/1/statuses/home_timeline.json?count=20&page=1"
 
   def setup
     super
-    stub_http_request(:get, "https://api.twitter.com/1/statuses/home_timeline.json?count=20&page=1").to_return(:body => fixture_file('home.json'))
+    stub_http_request(:get, HOME_URL).to_return(:body => fixture_file('home.json'))
   end
 
   Scenario "enable proxy via environment variable" do
@@ -20,7 +22,6 @@ Feature "using HTTP proxy" do
 
     Then "the application uses the proxy to fetch my home timeline" do
       should_use_proxy
-      @output[0].should == "pelit, 11 days ago:"
     end
   end
 
@@ -32,7 +33,6 @@ Feature "using HTTP proxy" do
 
     Then "the application uses the proxy to fetch my home timeline" do
       should_use_proxy
-      @output[0].should == "pelit, 11 days ago:"
     end
   end
 
@@ -44,7 +44,6 @@ Feature "using HTTP proxy" do
 
     Then "the application does not use the proxy to fetch my home timeline" do
       should_not_use_proxy
-      @output[0].should == "pelit, 11 days ago:"
     end
   end
 
@@ -55,10 +54,12 @@ Feature "using HTTP proxy" do
     nh.proxy_class?.should == true
     nh.instance_variable_get(:@proxy_address).should == PROXY_HOST
     nh.instance_variable_get(:@proxy_port).should == PROXY_PORT
+    assert_requested(:get, HOME_URL)
   end
 
   def should_not_use_proxy
     net_http.proxy_class?.should == false
+    assert_requested(:get, HOME_URL)
   end
 
   def net_http

data/test/example/{application_behavior_example.rb → user_help_example.rb}

@@ -1,14 +1,11 @@
 # coding: utf-8
 
 require "example_helper"
-require "fixture/oauth"
 
-include Tweetwine::Test::Fixture::OAuth
-
-Feature "application behavior" do
-  in_order_to "know about the application"
+Feature "user help" do
   as_a "user"
-  i_want_to "see helpful messages"
+  i_want_to "see help and error messages"
+  in_order_to "know how to use the application"
 
   %w{-v version ver v}.each do |arg|
     Scenario "show version with '#{arg}'" do
@@ -48,8 +45,9 @@ Usage: #{CLI::EXEC_NAME} [global_options...] [<command>] [command_options...]
         --no-colors                  Disable ANSI colors for output.
         --no-http-proxy              Disable HTTP(S) proxy.
         --no-url-shorten             Disable URL shortening.
-    -n, --num <n>                    Number of statuses per page (default 20).
-    -p, --page <p>                   Page number for statuses (default 1).
+    -n, --num <n>                    Number of tweets per page (default 20).
+    -p, --page <p>                   Page number for tweets (default 1).
+    -r, --reverse                    Show tweets in reverse order (default false).
     -u, --username <user>            User to authenticate (default '#{USER}').
     -v, --version                    Show version and exit.
 
@@ -139,35 +137,4 @@ Usage: tweetwine help [<command>]
       @status.exitstatus.should == UnknownCommandError.status_code
     end
   end
-
-  Scenario "authorize user with OAuth and save access token" do
-    When "I start the application with 'home' command and the command fails due to me being unauthorized" do
-      @command_url = "https://api.twitter.com/1/statuses/home_timeline.json?count=20&page=1"
-      stub_http_request(METHOD, REQUEST_TOKEN_URL).to_return(:body => REQUEST_TOKEN_RESPONSE)
-      stub_http_request(METHOD, ACCESS_TOKEN_URL).to_return(:body => ACCESS_TOKEN_RESPONSE)
-      stub_http_request(:get, @command_url).
-          to_return(:status => [401, 'Unauthorized']).then.
-          to_return(:body => fixture_file('home.json'))
-      @output = nil
-      @config_contents = nil
-      @config_mode = nil
-      config_file = 'tweetwine.tmp'
-      in_temp_dir do
-        @output = start_cli %W{--no-colors -f #{config_file} home}, [PIN], {}
-        @config_contents = YAML.load_file(config_file)
-        @config_mode = file_mode(config_file)
-      end
-    end
-
-    Then "the application authorizes me, saves access token to config file, and tries the command again" do
-      assert_requested(METHOD, REQUEST_TOKEN_URL)
-      assert_requested(METHOD, ACCESS_TOKEN_URL)
-      assert_requested(:get, @command_url, :headers => {'Authorization' => /^OAuth /}, :times => 2)
-      @output[0].should == "Please authorize: #{AUTHORIZE_URL}"
-      @output[1].should =~ /^Enter PIN:/
-      @output[2].should == "F1-kausi alkaa marraskuussa http://bit.ly/1qQwjQ"
-      @config_contents['oauth_access'].empty?.should == false
-      @config_mode.should == 0600
-    end
-  end
 end

data/test/unit/config_test.rb

@@ -186,7 +186,7 @@ class ConfigTest < UnitTestCase
       end
 
       teardown do
-        FileUtils.remove_entry_secure @tmp_dir
+        FileUtils.rm_rf @tmp_dir
       end
 
       should "ignore nonexisting config file for initial read" do

data/test/unit/http_test.rb

@@ -14,13 +14,9 @@ class HttpTest < UnitTestCase
   PAYLOAD = {:msg => 'gloomy night'}
 
   setup do
-    stub_sleep
     mock_ui
     @client = Http::Client.new
-  end
-
-  teardown do
-    restore_sleep
+    def @client.sleep(*args); end   # speed up tests
   end
 
   %w{http https}.each do |scheme|
@@ -178,22 +174,6 @@ class HttpTest < UnitTestCase
       end
     end
   end
-
-  private
-
-  def stub_sleep
-    Kernel.class_eval do
-      alias_method :__original_sleep, :sleep
-      define_method(:sleep) { |*args| }
-    end
-  end
-
-  def restore_sleep
-    Kernel.class_eval do
-      remove_method :sleep
-      alias_method :sleep, :__original_sleep
-    end
-  end
 end
 
 end

data/test/unit/oauth_test.rb

@@ -27,15 +27,15 @@ class OAuthTest < UnitTestCase
 
   should "raise AuthorizationError if OAuth dance fails due to HTTP 4xx response" do
     @http.expects(:post).
-        with(REQUEST_TOKEN_URL).
-        raises(HttpError.new(401, 'Unauthorized'))
+      with(REQUEST_TOKEN_URL).
+      raises(HttpError.new(401, 'Unauthorized'))
     assert_raise(AuthorizationError) { @oauth.authorize }
   end
 
   should "pass other exceptions than due to HTTP 4xx responses through" do
     @http.expects(:post).
-        with(REQUEST_TOKEN_URL).
-        raises(HttpError.new(503, 'Service Unavailable'))
+      with(REQUEST_TOKEN_URL).
+      raises(HttpError.new(503, 'Service Unavailable'))
     assert_raise(HttpError) { @oauth.authorize }
   end
 
@@ -56,16 +56,16 @@ class OAuthTest < UnitTestCase
 
   def expect_complete_oauth_dance
     @http.expects(:post).
-        with(REQUEST_TOKEN_URL).
-        returns(REQUEST_TOKEN_RESPONSE)
+      with(REQUEST_TOKEN_URL).
+      returns(REQUEST_TOKEN_RESPONSE)
     @ui.expects(:info).
-        with("Please authorize: #{AUTHORIZE_URL}")
+      with("Please authorize: #{AUTHORIZE_URL}")
     @ui.expects(:prompt).
-        with('Enter PIN').
-        returns(PIN)
+      with('Enter PIN').
+      returns(PIN)
     @http.expects(:post).
-        with(ACCESS_TOKEN_URL).
-        returns(ACCESS_TOKEN_RESPONSE)
+      with(ACCESS_TOKEN_URL).
+      returns(ACCESS_TOKEN_RESPONSE)
   end
 
   def fake_http_connection_and_request

data/test/unit/{util_test.rb → support_test.rb}

@@ -6,13 +6,44 @@ require "time"
 
 module Tweetwine::Test
 
-class UtilTest < UnitTestCase
-  include Util
+class SupportTest < UnitTestCase
+  include Support
 
-  context "for checking whether a string is blank" do
-    should("return true for nil")               { assert blank?(nil)  }
-    should("return true for empty string")      { assert blank?('')   }
-    should("return false for nonempty string")  { assert !blank?('a') }
+  context "for determining emptiness" do
+    [
+      [nil,     true,   "nil"],
+      ["",      true,   "empty string"],
+      ["foo",   false,  "nonempty string"],
+      [[],      true,   "empty array"],
+      [%w{a b}, false,  "nonempty array"]
+    ].each do |(subject, emptiness, description)|
+      should "return #{emptiness} for blank? with #{description}" do
+        assert_equal emptiness, blank?(subject)
+      end
+
+      should "return #{!emptiness} for present? with #{description}" do
+        assert_equal !emptiness, present?(subject)
+      end
+
+      should "return non-empty subject for presence, when subject is #{description}" do
+        actual = presence(subject)
+        expected = present?(subject) ? subject : nil
+        assert_same expected, actual
+      end
+
+      should "return value of block for presence, when subject is #{description}" do
+        actual = presence(subject) { |s| s.size }
+        expected = present?(subject) ? subject.size : nil
+        assert_same expected, actual
+      end
+
+      should "allow presence to be used with || operator, when subject is #{description}" do
+        alternative = "hey"
+        actual = presence(subject) || alternative
+        expected = present?(subject) ? subject : alternative
+        assert_same expected, actual
+      end
+    end
   end
 
   context "for humanizing time differences" do
@@ -154,38 +185,6 @@ class UtilTest < UnitTestCase
     end
   end
 
-  context "for percent-encoding strings" do
-    [
-      %w{a a},
-      %w{B B},
-      %w{3 3},
-      %w{. period},
-      %w{- dash},
-      %w{_ underscore},
-    ].each do |char, desc|
-      should "not encode safe characters, case #{desc}" do
-        assert_equal char, percent_encode(char)
-      end
-    end
-
-    should "encode space character with percent-encoding, not with '+' character" do
-      assert_equal "%20", percent_encode(" ")
-    end
-
-    [
-      %w{& %26 ampersand},
-      %w{? %3F question mark},
-      %w{/ %2F slash},
-      %w{: %3A colon},
-      %w{, %2C comma}
-    ].each do |char, expected, desc|
-      should "encode unsafe characters that URI.encode leaves by default unencoded, case #{desc}" do
-        assert_equal char, URI.encode(char)
-        assert_equal expected, percent_encode(char)
-      end
-    end
-  end
-
   context "for unescaping HTML" do
     [
       %w{a a},

data/test/unit/tweet_helper.rb

@@ -0,0 +1,83 @@
+# coding: utf-8
+
+module Tweetwine::Test
+  module TweetHelper
+    FIELD_PATHS = {
+      :from_user  => %w{screen_name},
+      :to_user    => %w{status in_reply_to_screen_name},
+      :retweet    => %w{retweeted_status},
+      :created_at => %w{status created_at},
+      :status     => %w{status text}
+    }.freeze
+
+    DEFAULT_FIELD_VALUES = {
+      :from_user  => 'fred',
+      :to_user    => nil,
+      :retweet    => nil,
+      :created_at => Time.utc(2011, 'feb', 17, 22, 28, 0).iso8601,
+      :status     => nil
+    }.freeze
+
+    RECORD_SKELETON = {
+      'screen_name'       => nil,
+      'retweeted_status'  => nil,
+      'status'            => {
+        'in_reply_to_screen_name' => nil,
+        'created_at'              => nil,
+        'text'                    => nil
+      }.freeze
+    }.freeze
+
+    def create_record(fields = {})
+      record = create_nonrt_record(nonrt_fields(fields))
+      modify_to_rt_record(record, fields[:rt_user]) if fields[:rt_user]
+      record
+    end
+
+    def create_tweet(fields = {})
+      Tweetwine::Tweet.new(create_record(fields), FIELD_PATHS)
+    end
+
+    private
+
+    def find_hash_of_field_path(hash, path)
+      path = [path] unless path.is_a? Array
+      if path.size > 1
+        hash_path, field = path[0..-2], path.last
+        [Tweetwine::Support.find_hash_path(hash, hash_path), field]
+      else
+        [hash, path.first]
+      end
+    end
+
+    def nonrt_fields(fields)
+      DEFAULT_FIELD_VALUES.merge(fields.reject { |(k, v)| k == :rt_user })
+    end
+
+    def create_nonrt_record(fields)
+      FIELD_PATHS.inject(deep_copy(RECORD_SKELETON)) do |result, (path_name, path_actual)|
+        hash, field = find_hash_of_field_path(result, path_actual)
+        hash[field] = fields[path_name]
+        result
+      end
+    end
+
+    def modify_to_rt_record(record, rt_user)
+      rt_hash, rt_field = find_hash_of_field_path(record, FIELD_PATHS[:retweet])
+      fr_hash, fr_field = find_hash_of_field_path(record, FIELD_PATHS[:from_user])
+      st_hash, st_field = find_hash_of_field_path(record, FIELD_PATHS[:status])
+      rt_hash[rt_field] = {
+        fr_field => fr_hash[fr_field].dup,
+        'status' => st_hash.dup
+      }
+      fr_hash[fr_field] = rt_user
+      st_hash[st_field] = 'retweeted status text. you should not see me.'
+      cr_hash, cr_field = find_hash_of_field_path(record, FIELD_PATHS[:created_at])
+      cr_hash[cr_field] = 'old created timestamp. you should not see me.'
+    end
+
+    def deep_copy(obj)
+      Marshal.load(Marshal.dump(obj))
+    end
+  end
+end

data/test/unit/tweet_test.rb

@@ -0,0 +1,153 @@
+# coding: utf-8
+
+require 'unit_helper'
+require 'tweet_helper'
+
+module Tweetwine::Test
+
+class TweetTest < UnitTestCase
+  include TweetHelper
+
+  context "for initialization" do
+    should "raise exception if from user field is not found" do
+      assert_raise(ArgumentError) { create_tweet(:from_user => nil) }
+    end
+  end
+
+  context "for equivalence" do
+    should "equal to another tweet with same content" do
+      status = 'foo'
+      first  = create_tweet(:status => status)
+      second = create_tweet(:status => status)
+      assert_equal first, second
+    end
+
+    should "not equal to another tweet with different content" do
+      first  = create_tweet(:status => 'ahem')
+      second = create_tweet(:status => 'hmph')
+      assert_not_equal first, second
+    end
+  end
+
+  context "for handling regular tweet" do
+    setup do
+      @status = 'lurking'
+      @tweet = create_tweet(:status => @status)
+    end
+
+    should "detect tweet as not retweet" do
+      assert_equal false, @tweet.retweet?
+    end
+
+    should "not have retweeting user" do
+      assert_nil @tweet.rt_user
+    end
+
+    should "have originating user field" do
+      assert_equal(DEFAULT_FIELD_VALUES[:from_user], @tweet.from_user)
+    end
+
+    should "detect tweet as not being a reply" do
+      assert_equal false, @tweet.reply?
+    end
+
+    should "have no destination user" do
+      assert_nil @tweet.to_user
+    end
+
+    should "detect having creation timestamp" do
+      assert_equal true, @tweet.timestamped?
+    end
+
+    should "have creation timestamp" do
+      assert_equal Time.parse(DEFAULT_FIELD_VALUES[:created_at]), @tweet.created_at
+    end
+
+    should "detect having status" do
+      assert_equal true, @tweet.status?
+    end
+
+    should "have status" do
+      assert_equal @status, @tweet.status
+    end
+  end
+
+  context "for handling replying tweet" do
+    setup do
+      @to_user = 'jacko'
+      @tweet = create_tweet(:to_user => @to_user)
+    end
+
+    should "detect tweet as being a reply" do
+      assert_equal true, @tweet.reply?
+    end
+
+    should "have destination user" do
+      assert_equal @to_user, @tweet.to_user
+    end
+  end
+
+  context "for handling retweet" do
+    setup do
+      @rt_user = 'jonathan'
+      @status = 'tweet worth retweeting'
+      @tweet = create_tweet(:rt_user => @rt_user, :status => @status)
+    end
+
+    should "detect tweet as retweet" do
+      assert_equal true, @tweet.retweet?
+    end
+
+    should "have retweeting user" do
+      assert_equal @rt_user, @tweet.rt_user
+    end
+
+    should "have originating user" do
+      assert_equal DEFAULT_FIELD_VALUES[:from_user], @tweet.from_user
+    end
+
+    should "detect having creation timestamp of the original tweet" do
+      assert_equal true, @tweet.timestamped?
+    end
+
+    should "have creation timestamp of the original tweet" do
+      assert_equal Time.parse(DEFAULT_FIELD_VALUES[:created_at]), @tweet.created_at
+    end
+
+    should "detect having status of the original tweet" do
+      assert_equal true, @tweet.status?
+    end
+
+    should "have status of the original tweet" do
+      assert_equal @status, @tweet.status
+    end
+  end
+
+  context "for handling tweet with just user info" do
+    setup do
+      @tweet = create_tweet(:to_user => nil, :status => nil, :created_at => nil)
+    end
+
+    should "detect tweet as not retweet" do
+      assert_equal false, @tweet.retweet?
+    end
+
+    should "have originating user field" do
+      assert_equal(DEFAULT_FIELD_VALUES[:from_user], @tweet.from_user)
+    end
+
+    should "detect tweet as not being a reply" do
+      assert_equal false, @tweet.reply?
+    end
+
+    should "detect having no creation timestamp" do
+      assert_equal false, @tweet.timestamped?
+    end
+
+    should "detect having no status" do
+      assert_equal false, @tweet.status?
+    end
+  end
+end
+
+end