tweetwine 0.4.1 → 0.4.2

data/test/unit/obfuscate_test.rb

@@ -1,13 +1,13 @@
 # coding: utf-8
 
-require "unit_helper"
+require 'unit/helper'
 
-module Tweetwine::Test
+module Tweetwine::Test::Unit
 
-class ObfuscateTest < UnitTestCase
+class ObfuscateTest < TestCase
   include Obfuscate
 
-  should "obfuscate symmetrically" do
+  it "obfuscates symmetrically" do
     str = 'hey, jack'
     assert_equal(str, obfuscate(obfuscate(str)))
   end

data/test/unit/option_parser_test.rb

@@ -1,11 +1,11 @@
 # coding: utf-8
 
-require "unit_helper"
+require 'unit/helper'
 
-module Tweetwine::Test
+module Tweetwine::Test::Unit
 
-class OptionParserTest < UnitTestCase
-  setup do
+class OptionParserTest < TestCase
+  before do
     @parser = OptionParser.new do |parser, options|
       parser.on '-c', '--colors',           'Enable colors.' do
         options[:colors] = true
@@ -16,41 +16,41 @@ class OptionParserTest < UnitTestCase
     end
   end
 
-  should "return empty options if no options (no default values)" do
+  it "returns empty options if no options (no default values)" do
     options = @parser.parse %w{}
     assert options.empty?
   end
 
-  should "return only options that occurred (no default values)" do
+  it "returns only options that occurred (no default values)" do
     options = @parser.parse %w{-u jack}
     assert_equal({:username => 'jack'}, options)
   end
 
-  should "return copy of options after parsing" do
+  it "returns copy of options after parsing" do
     options1 = @parser.parse %w{-u jack}
     options2 = @parser.parse %w{-c}
     assert_equal({:username => 'jack'}, options1)
     assert_equal({:colors   => true},   options2)
   end
 
-  should "parse from beginning, removing recognized options" do
+  it "parses from beginning, removing recognized options" do
     args = %w{-u jack foo bar}
     options = @parser.parse args
     assert_equal(%w{foo bar}, args)
   end
 
-  should "parse from beginning, leaving option-like arguments after non-option arguments in place" do
+  it "parses from beginning, leaving option-like arguments after non-option arguments in place" do
     args = %w{-c foo -u jack bar}
     options = @parser.parse args
     assert_equal(%w{foo -u jack bar}, args)
     assert_equal({:colors => true}, options)
   end
 
-  should "raise exception upon unrecognized option" do
-    assert_raise(CommandLineError) { @parser.parse %w{-d} }
+  it "raises exception upon unrecognized option" do
+    assert_raises(CommandLineError) { @parser.parse %w{-d} }
   end
 
-  should "describe option syntax" do
+  it "describes option syntax" do
     description = @parser.help.split("\n")
     assert_match(/\A\s+\-c, \-\-colors\s+Enable colors.\z/,         description[0])
     assert_match(/\A\s+\-u, \-\-username <user>\s+Specify user.\z/, description[1])

data/test/unit/promise_test.rb

@@ -1,11 +1,11 @@
 # coding: utf-8
 
-require "unit_helper"
+require 'unit/helper'
 
-module Tweetwine::Test
+module Tweetwine::Test::Unit
 
-class PromiseTest < UnitTestCase
-  setup do
+class PromiseTest < TestCase
+  before do
     @result = nil
     @action_called = 0
     @promise = Promise.new do
@@ -14,13 +14,13 @@ class PromiseTest < UnitTestCase
     end
   end
 
-  should "evaluate action when calling a method" do
+  it "evaluates action when calling a method" do
     result = @promise.to_i
     assert_same(@result, result)
     assert_equal(1, @action_called)
   end
 
-  should "memoize already evaluated action" do
+  it "memoizes already evaluated action" do
     result = @promise.to_i
     assert_same(@result, result)
     result = @promise.to_i
@@ -28,22 +28,22 @@ class PromiseTest < UnitTestCase
     assert_equal(1, @action_called)
   end
 
-  should "inspect the proxy object if action is not evaluated" do
+  it "inspects the proxy object if action is not evaluated" do
     assert_match(/^#<Tweetwine::Promise/, @promise.inspect)
     assert_equal(0, @action_called)
   end
 
-  should "inspect the evaluated object if action is evaluated" do
+  it "inspects the evaluated object if action is evaluated" do
     eval_action
     assert_match(/^\d$/, @promise.inspect)
   end
 
-  should "pass #object_id call to the evaluation result" do
+  it "passes #object_id call to the evaluation result" do
     eval_action     # in order to have @result set
     assert_equal(@result.object_id, @promise.object_id)
   end
 
-  should "pass #to_s call to the evaluation result" do
+  it "passes #to_s call to the evaluation result" do
     eval_action     # in order to have @result set
     assert_equal(@result.to_s, @promise.to_s)
   end

data/test/unit/support_test.rb

@@ -1,15 +1,14 @@
 # coding: utf-8
 
-require "unit_helper"
+require 'unit/helper'
+require 'time'
 
-require "time"
+module Tweetwine::Test::Unit
 
-module Tweetwine::Test
-
-class SupportTest < UnitTestCase
+class SupportTest < TestCase
   include Support
 
-  context "for determining emptiness" do
+  describe "for determining emptiness" do
     [
       [nil,     true,   "nil"],
       ["",      true,   "empty string"],
@@ -17,27 +16,27 @@ class SupportTest < UnitTestCase
       [[],      true,   "empty array"],
       [%w{a b}, false,  "nonempty array"]
     ].each do |(subject, emptiness, desc)|
-      should "return #{emptiness} for blank? with #{desc}" do
+      it "returns #{emptiness} for blank? with #{desc}" do
         assert_equal emptiness, blank?(subject)
       end
 
-      should "return #{!emptiness} for present? with #{desc}" do
+      it "returns #{!emptiness} for present? with #{desc}" do
         assert_equal !emptiness, present?(subject)
       end
 
-      should "return non-empty subject for presence, when subject is #{desc}" do
+      it "returns non-empty subject for presence, when subject is #{desc}" do
         actual = presence(subject)
         expected = present?(subject) ? subject : nil
         assert_same expected, actual
       end
 
-      should "return value of block for presence, when subject is #{desc}" do
+      it "returns value of block for presence, when subject is #{desc}" 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 #{desc}" do
+      it "allows presence to be used with || operator, when subject is #{desc}" do
         alternative = "hey"
         actual = presence(subject) || alternative
         expected = present?(subject) ? subject : alternative
@@ -46,8 +45,8 @@ class SupportTest < UnitTestCase
     end
   end
 
-  context "for humanizing time differences" do
-    should "accept string and time arguments" do
+  describe "for humanizing time differences" do
+    it "accepts string and time arguments" do
       start = '2009-01-01 01:01:00'
       stop  = Time.parse '2009-01-01 01:03:00'
       assert_commutative([2, 'min'], [start, stop]) do |a, b|
@@ -55,7 +54,7 @@ class SupportTest < UnitTestCase
       end
     end
 
-    should "use second granularity for time differences smaller than a minute" do
+    it "uses second granularity for time differences smaller than a minute" do
       [
         [0,   '2009-01-01 01:00:00', '2009-01-01 01:00:00'],
         [1,   '2009-01-01 00:00:59', '2009-01-01 00:01:00'],
@@ -68,7 +67,7 @@ class SupportTest < UnitTestCase
       end
     end
 
-    should "use minute granularity for time differences greater than a minute but smaller than an hour" do
+    it "uses minute granularity for time differences greater than a minute but smaller than an hour" do
       [
         [1,   '2009-01-01 01:00:00', '2009-01-01 01:01:00'],
         [2,   '2009-01-01 01:01:00', '2009-01-01 01:03:29'],
@@ -83,7 +82,7 @@ class SupportTest < UnitTestCase
       end
     end
 
-    should "use hour granularity for time differences greater than an hour but smaller than a day" do
+    it "uses hour granularity for time differences greater than an hour but smaller than a day" do
       [
         [1, 'hour',   '2009-01-01 01:00', '2009-01-01 02:00'],
         [2, 'hours',  '2009-01-01 01:00', '2009-01-01 03:00'],
@@ -96,7 +95,7 @@ class SupportTest < UnitTestCase
       end
     end
 
-    should "use day granularity for time differences greater than a day" do
+    it "uses day granularity for time differences greater than a day" do
       [
         [1, 'day',    '2009-01-01 01:00', '2009-01-02 01:00'],
         [2, 'days',   '2009-01-01 01:00', '2009-01-03 01:00'],
@@ -110,7 +109,7 @@ class SupportTest < UnitTestCase
     end
   end
 
-  context "for recursively copying a hash" do
+  describe "for recursively copying a hash" do
     ALL_KEYS_STRINGS = {
       'alpha'   => 'A',
       'beta'    => 'B',
@@ -130,7 +129,7 @@ class SupportTest < UnitTestCase
       }
     }
 
-    should "stringify hash keys" do
+    it "stringifies hash keys" do
       given = {
         :alpha    => 'A',
         'beta'    => 'B',
@@ -143,7 +142,7 @@ class SupportTest < UnitTestCase
       assert_equal ALL_KEYS_STRINGS, stringify_hash_keys(given)
     end
 
-    should "symbolize hash keys" do
+    it "symbolizes hash keys" do
       given = {
         'alpha'   => 'A',
         :beta     => 'B',
@@ -156,30 +155,30 @@ class SupportTest < UnitTestCase
       assert_equal ALL_KEYS_SYMBOLS, symbolize_hash_keys(given)
     end
 
-    should "have symmetric property for stringify and symbolize" do
+    it "has symmetric property for stringify and symbolize" do
       assert_equal ALL_KEYS_STRINGS, stringify_hash_keys(symbolize_hash_keys(ALL_KEYS_STRINGS))
       assert_equal ALL_KEYS_SYMBOLS, symbolize_hash_keys(stringify_hash_keys(ALL_KEYS_SYMBOLS))
     end
   end
 
-  context "for parsing integers from strings, with minimum and default values, and naming parameter" do
-    should "return an integer from its string presentation" do
+  describe "for parsing integers from strings, with minimum and default values, and naming parameter" do
+    it "returns an integer from its string presentation" do
       assert_equal 6, parse_int_gt("6", 8, 4, "ethical working hours per day")
     end
 
-    should "return default value if the string parameter is falsy" do
+    it "returns default value if the string parameter is falsy" do
       assert_equal 8, parse_int_gt(nil, 8, 4, "ethical working hours per day")
       assert_equal 8, 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) { parse_int_gt(3, 8, 4, "ethical working hours per day") }
-      assert_raise(ArgumentError) { parse_int_gt("3", 8, 4, "ethical working hours per day") }
+    it "raises an error if the parsed value is less than the minimum parameter" do
+      assert_raises(ArgumentError) { parse_int_gt(3, 8, 4, "ethical working hours per day") }
+      assert_raises(ArgumentError) { 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 of the string by using a single matching group of the regexp" do
+  describe "for replacing the contents of a string with a regexp that uses group syntax" do
+    it "replaces the contents of the string by using a single matching group of the regexp" do
       assert_equal "hEllo", str_gsub_by_group("hello", /.+(e)/) { |s| s.upcase }
       assert_equal "hEllO", str_gsub_by_group("hello", /([aeio])/) { |s| s.upcase }
       assert_equal "h<b>e</b>ll<b>o</b>", str_gsub_by_group("hello", /([aeio])/) { |s| "<b>#{s}</b>" }
@@ -187,7 +186,7 @@ class SupportTest < UnitTestCase
       assert_equal "hell", str_gsub_by_group("hello", /.+([io])/) { |s| "" }
     end
 
-    should "replace the contents of the string by using multiple matching groups of the regexp" do
+    it "replaces the contents of the string by using multiple matching groups of the regexp" do
       assert_equal "hEllO", str_gsub_by_group("hello", /([ae]).+([io])/) { |s| s.upcase }
       assert_equal "h<b>e</b>ll<b>o</b>", str_gsub_by_group("hello", /([ae]).+([io])/) { |s| "<b>#{s}</b>" }
       assert_equal "hll", str_gsub_by_group("hello", /.+([ae]).+([io])/) { |s| "" }
@@ -195,32 +194,32 @@ class SupportTest < UnitTestCase
       assert_equal "hEllo", str_gsub_by_group("hello", /^(a)|.+(e)/) { |s| s.upcase }
     end
 
-    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
+    it "replaces 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 "", str_gsub_by_group("", /el/) { |s| s.upcase }
       assert_equal "hELlo", str_gsub_by_group("hello", /el/) { |s| s.upcase }
       assert_equal "h<b>e</b>ll<b>o</b>", str_gsub_by_group("hello", /e|o/) { |s| "<b>#{s}</b>" }
     end
 
-    should "not change the contents of the string if the regexp does not match" do
+    it "does not change the contents of the string if the regexp does not match" do
       assert_equal "", str_gsub_by_group("", /.+([ai])/) { |s| s.upcase }
       assert_equal "hello", str_gsub_by_group("hello", /.+([ai])/) { |s| s.upcase }
       assert_equal "hello", 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
+    it "returns a new string as the result, leaving the original string unmodified" do
       org_str = "hello"
       new_str = str_gsub_by_group(org_str, /e/) { |s| s.upcase }
-      assert_not_same new_str, org_str
+      refute_same new_str, org_str
       assert_equal "hello", org_str
       assert_equal "hEllo", new_str
     end
 
-    should "work with UTF-8 input" do
+    it "works with UTF-8 input" do
       assert_equal "Ali<b>en</b>³,<b>Pre</b>dator", str_gsub_by_group("Alien³,Predator", /(en).+(Pre)/) { |s| "<b>#{s}</b>" }
     end
   end
 
-  context "for unescaping HTML" do
+  describe "for unescaping HTML" do
     [
       %w{a a},
       %w{B B},
@@ -230,7 +229,7 @@ class SupportTest < UnitTestCase
       %w{_ underscore},
       %w{+ plus}
     ].each do |(char, desc)|
-      should "not affect already unescaped characters, case #{desc}" do
+      it "does not affect already unescaped characters, case #{desc}" do
         assert_equal char, unescape_html(char)
       end
     end
@@ -242,14 +241,14 @@ class SupportTest < UnitTestCase
       %w{&quot; "},
       %W{&nbsp; \ }
     ].each do |(input, expected)|
-      should "unescape HTML-escaped characters, case '#{input}'" do
+      it "unescapes HTML-escaped characters, case '#{input}'" do
         assert_equal expected, unescape_html(input)
       end
     end
   end
 
-  context "for traversing a hash with a path expression for finding a value" do
-    setup do
+  describe "for traversing a hash with a path expression for finding a value" do
+    before do
       @inner_hash = {
         :salmon => "slick"
       }
@@ -262,22 +261,22 @@ class SupportTest < UnitTestCase
       @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
+    it "supports both a non-array and a single element array path for finding the value" do
       assert_equal @outer_hash[:simple], find_hash_path(@outer_hash, :simple)
       assert_equal @outer_hash[:simple], find_hash_path(@outer_hash, [:simple])
     end
 
-    should "find a nested value with an array path" do
+    it "finds a nested value with an array path" do
       assert_equal @inner_hash[:salmon], find_hash_path(@outer_hash, [:inner, :salmon])
     end
 
-    should "return the default value of the hash if the value cannot be found" do
+    it "returns the default value of the hash if the value cannot be found" do
       assert_equal @outer_hash.default, find_hash_path(@outer_hash, :difficult)
       assert_equal @inner_hash.default, find_hash_path(@outer_hash, [:inner, :cucumber])
       assert_equal @outer_hash.default, find_hash_path(@outer_hash, [:fishy, :no_such])
     end
 
-    should "return the default value of the hash if invalid path value" do
+    it "returns the default value of the hash if invalid path value" do
       [
         nil,
         [:no_such, nil],
@@ -289,7 +288,7 @@ class SupportTest < UnitTestCase
       end
     end
 
-    should "return nil if nil hash value" do
+    it "returns nil if nil hash value" do
       assert_equal nil, find_hash_path(nil, [:salmon])
     end
   end

data/test/unit/tweet_helper.rb

@@ -2,7 +2,7 @@
 
 require 'timecop'
 
-module Tweetwine::Test
+module Tweetwine::Test::Unit
   module TweetHelper
     FIELD_PATHS = {
       :from_user  => %w{screen_name},

data/test/unit/tweet_test.rb

@@ -1,150 +1,150 @@
 # coding: utf-8
 
-require 'unit_helper'
-require 'tweet_helper'
+require 'unit/helper'
+require 'unit/tweet_helper'
 
-module Tweetwine::Test
+module Tweetwine::Test::Unit
 
-class TweetTest < UnitTestCase
+class TweetTest < TestCase
   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) }
+  describe "for initialization" do
+    it "raises exception if from user field is not found" do
+      assert_raises(ArgumentError) { create_tweet(:from_user => nil) }
     end
   end
 
-  context "for equality" do
-    should "equal to another tweet with same content" do
+  describe "for equality" do
+    it "equals 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
+    it "does not equal to another tweet with different content" do
       first  = create_tweet(:status => 'ahem')
       second = create_tweet(:status => 'hmph')
-      assert_not_equal first, second
+      refute_equal first, second
     end
   end
 
-  context "for handling regular tweet" do
-    setup do
+  describe "for handling regular tweet" do
+    before do
       @status = 'lurking'
       @tweet = create_tweet(:status => @status)
     end
 
-    should "detect tweet as not retweet" do
+    it "detects tweet as not retweet" do
       assert_equal false, @tweet.retweet?
     end
 
-    should "not have retweeting user" do
+    it "does not have retweeting user" do
       assert_nil @tweet.rt_user
     end
 
-    should "have originating user field" do
+    it "has originating user field" do
       assert_equal(DEFAULT_FIELD_VALUES[:from_user], @tweet.from_user)
     end
 
-    should "detect tweet as not being a reply" do
+    it "detects tweet as not being a reply" do
       assert_equal false, @tweet.reply?
     end
 
-    should "have no destination user" do
+    it "has no destination user" do
       assert_nil @tweet.to_user
     end
 
-    should "detect having creation timestamp" do
+    it "detects having creation timestamp" do
       assert_equal true, @tweet.timestamped?
     end
 
-    should "have creation timestamp" do
+    it "has creation timestamp" do
       assert_equal Time.parse(DEFAULT_FIELD_VALUES[:created_at]), @tweet.created_at
     end
 
-    should "detect having status" do
+    it "detects having status" do
       assert_equal true, @tweet.status?
     end
 
-    should "have status" do
+    it "has status" do
       assert_equal @status, @tweet.status
     end
   end
 
-  context "for handling replying tweet" do
-    setup do
+  describe "for handling replying tweet" do
+    before do
       @to_user = 'jacko'
       @tweet = create_tweet(:to_user => @to_user)
     end
 
-    should "detect tweet as being a reply" do
+    it "detects tweet as being a reply" do
       assert_equal true, @tweet.reply?
     end
 
-    should "have destination user" do
+    it "has destination user" do
       assert_equal @to_user, @tweet.to_user
     end
   end
 
-  context "for handling retweet" do
-    setup do
+  describe "for handling retweet" do
+    before do
       @rt_user = 'jonathan'
       @status = 'tweet worth retweeting'
       @tweet = create_tweet(:rt_user => @rt_user, :status => @status)
     end
 
-    should "detect tweet as retweet" do
+    it "detects tweet as retweet" do
       assert_equal true, @tweet.retweet?
     end
 
-    should "have retweeting user" do
+    it "has retweeting user" do
       assert_equal @rt_user, @tweet.rt_user
     end
 
-    should "have originating user" do
+    it "has originating user" do
       assert_equal DEFAULT_FIELD_VALUES[:from_user], @tweet.from_user
     end
 
-    should "detect having creation timestamp of the original tweet" do
+    it "detects having creation timestamp of the original tweet" do
       assert_equal true, @tweet.timestamped?
     end
 
-    should "have creation timestamp of the original tweet" do
+    it "has 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
+    it "detects having status of the original tweet" do
       assert_equal true, @tweet.status?
     end
 
-    should "have status of the original tweet" do
+    it "has status of the original tweet" do
       assert_equal @status, @tweet.status
     end
   end
 
-  context "for handling tweet with just user info" do
-    setup do
+  describe "for handling tweet with just user info" do
+    before do
       @tweet = create_tweet(:to_user => nil, :status => nil, :created_at => nil)
     end
 
-    should "detect tweet as not retweet" do
+    it "detects tweet as not retweet" do
       assert_equal false, @tweet.retweet?
     end
 
-    should "have originating user field" do
+    it "has originating user field" do
       assert_equal(DEFAULT_FIELD_VALUES[:from_user], @tweet.from_user)
     end
 
-    should "detect tweet as not being a reply" do
+    it "detects tweet as not being a reply" do
       assert_equal false, @tweet.reply?
     end
 
-    should "detect having no creation timestamp" do
+    it "detects having no creation timestamp" do
       assert_equal false, @tweet.timestamped?
     end
 
-    should "detect having no status" do
+    it "detects having no status" do
       assert_equal false, @tweet.status?
     end
   end