tweetwine 0.4.1 → 0.4.2

data/test/unit/config_test.rb

@@ -1,18 +1,17 @@
 # coding: utf-8
 
-require "unit_helper"
+require 'unit/helper'
+require 'fileutils'
+require 'tempfile'
+require 'yaml'
 
-require "fileutils"
-require "tempfile"
-require "yaml"
+module Tweetwine::Test::Unit
 
-module Tweetwine::Test
+class ConfigTest < TestCase
+  CONFIG_FILE = fixture_path 'config_unit.yaml'
 
-class ConfigTest < UnitTestCase
-  CONFIG_FILE = Helper.fixture_path('config_unit.yaml')
-
-  context "when given command line arguments, no environment variables, no config file" do
-    setup do
+  describe "when given command line arguments, no environment variables, no config file" do
+    before do
       @args = %w{--opt cmd_opt --defopt cmd_defopt left overs}
       default_config = {:defopt => 'defopt'}
       @config = Config.read(@args, default_config) do |args|
@@ -21,21 +20,21 @@ class ConfigTest < UnitTestCase
       end
     end
 
-    should "have option defined from command line" do
+    it "has option defined from command line" do
       assert_equal 'cmd_opt', @config[:opt]
     end
 
-    should "override option default value from command line" do
+    it "overrides option default value from command line" do
       assert_equal 'cmd_defopt', @config[:defopt]
     end
 
-    should "leave remaining command line arguments unconsumed" do
+    it "leaves remaining command line arguments unconsumed" do
       assert_equal %w{left overs}, @args
     end
   end
 
-  context "when given command line arguments, environment variables, no config file" do
-    setup do
+  describe "when given command line arguments, environment variables, no config file" do
+    before do
       ENV['opt']    = 'env_opt'
       ENV['defopt'] = 'env_defopt'
       ENV['envopt'] = 'env_envopt'
@@ -47,27 +46,27 @@ class ConfigTest < UnitTestCase
       end
     end
 
-    teardown do
-      ENV['opt']    = nil
-      ENV['defopt'] = nil
-      ENV['envopt'] = nil
+    after do
+      ENV.delete 'opt'
+      ENV.delete 'defopt'
+      ENV.delete 'envopt'
     end
 
-    should "have option defined from environment variable" do
+    it "has option defined from environment variable" do
       assert_equal 'env_envopt', @config[:envopt]
     end
 
-    should "override option value from command line over environment variable" do
+    it "overrides option value from command line over environment variable" do
       assert_equal 'cmd_opt', @config[:opt]
     end
 
-    should "override option default value from environment variable" do
+    it "overrides option default value from environment variable" do
       assert_equal 'env_defopt', @config[:defopt]
     end
   end
 
-  context "when given command line arguments, no environment variables, config file" do
-    setup do
+  describe "when given command line arguments, no environment variables, config file" do
+    before do
       @args = %w{--opt cmd_opt}
       default_config = {:config_file => CONFIG_FILE, :defopt => 'defopt'}
       @config = Config.read(@args, default_config) do |args|
@@ -76,21 +75,21 @@ class ConfigTest < UnitTestCase
       end
     end
 
-    should "have option defined from config file" do
+    it "has option defined from config file" do
       assert_equal 'file_fileopt', @config[:fileopt]
     end
 
-    should "override option value from command line over config file" do
+    it "overrides option value from command line over config file" do
       assert_equal 'cmd_opt', @config[:opt]
     end
 
-    should "override option default value from config file" do
+    it "overrides option default value from config file" do
       assert_equal 'file_defopt', @config[:defopt]
     end
   end
 
-  context "when given command line arguments, environment variables, config file" do
-    setup do
+  describe "when given command line arguments, environment variables, config file" do
+    before do
       @args = %w{--opt2 cmd_opt2}
       ENV['opt']  = 'env_opt'
       ENV['opt2'] = 'env_opt2'
@@ -100,67 +99,67 @@ class ConfigTest < UnitTestCase
       end
     end
 
-    teardown do
-      ENV['opt']  = nil
-      ENV['opt2'] = nil
+    after do
+      ENV.delete 'opt'
+      ENV.delete 'opt2'
     end
 
-    should "override option value from environment variable over config file" do
+    it "overrides option value from environment variable over config file" do
       assert_equal 'env_opt', @config[:opt]
     end
 
-    should "override option value from command line over environment variable and config file" do
+    it "overrides option value from command line over environment variable and config file" do
       assert_equal 'cmd_opt2', @config[:opt2]
     end
   end
 
-  context "when handling command line arguments without parser" do
-    setup do
+  describe "when handling command line arguments without parser" do
+    before do
       ENV['opt'] = 'env_opt'
       @args = %w{--opt cmd_opt --defopt cmd_defopt}
       default_config = {:config_file => CONFIG_FILE, :defopt => 'defopt', :env_lookouts => [:opt]}
       @config = Config.read(@args, default_config)
     end
 
-    teardown do
-      ENV['opt'] = nil
+    after do
+      ENV.delete 'opt'
     end
 
-    should "ignore command line arguments, using environment variables and config file for options if available" do
+    it "ignores command line arguments, using environment variables and config file for options if available" do
       assert_equal 'env_opt', @config[:opt]
       assert_equal 'file_defopt', @config[:defopt]
     end
   end
 
-  context "when handling environment variables" do
-    setup do
+  describe "when handling environment variables" do
+    before do
       ENV['visible'] = 'env_visible'
       ENV['hidden']  = 'env_hidden'
       ENV['empty']   = ''
       @config = Config.read([], :env_lookouts => [:visible, :empty])
     end
 
-    teardown do
-      ENV['visible'] = nil
-      ENV['hidden'] = nil
-      ENV['empty'] = nil
+    after do
+      ENV.delete 'visible'
+      ENV.delete 'hidden'
+      ENV.delete 'empty'
     end
 
-    should "consider only specified environment variables that are nonempty" do
+    it "considers only specified environment variables that are nonempty" do
       assert_equal 'env_visible', @config[:visible]
     end
 
-    should "not consider empty environment variables" do
+    it "does not consider empty environment variables" do
       assert_equal nil, @config[:empty]
     end
 
-    should "not consider unspecified environment variables" do
+    it "does not consider unspecified environment variables" do
       assert_equal nil, @config[:hidden]
     end
   end
 
-  context "when handling the config file" do
-    should "allow specifying configuration file from command line arguments" do
+  describe "when handling the config file" do
+    it "allows specifying configuration file from command line arguments" do
       @args = ['-f', CONFIG_FILE]
       @config = Config.read(@args, {}) do
         @args.slice!(0..1)
@@ -170,13 +169,21 @@ class ConfigTest < UnitTestCase
       assert_equal 'file_defopt', @config[:defopt]
     end
 
-    should "raise exception when trying to save and no config file is specified" do
+    it "raises exception when trying to save and no config file is specified" do
       @config = Config.read()
-      assert_raise(RuntimeError) { @config.save }
+      assert_raises(RuntimeError) { @config.save }
     end
 
-    context "when config file does not exist" do
-      setup do
+    it "raises exception when trying to read invalid config file" do
+      Tempfile.open('.tweetwine') do |tf|
+        file = tf.path
+        FileUtils.touch file
+        assert_raises(ConfigError) { Config.read [], :config_file => file }
+      end
+    end
+
+    describe "when config file does not exist" do
+      before do
         @tmp_dir = Dir.mktmpdir
         @file = @tmp_dir + '/.tweetwine'
         @excludes = [:secret]
@@ -185,22 +192,22 @@ class ConfigTest < UnitTestCase
         @expected_config = {'new_opt' => 'to_file'}
       end
 
-      teardown do
+      after do
         FileUtils.rm_rf @tmp_dir
       end
 
-      should "ignore nonexisting config file for initial read" do
+      it "ignores nonexisting config file for initial read" do
         assert_contains_exactly @default_config.keys, @config.keys
       end
 
-      should "save config to the file, implicitly without config file, env lookouts, and excludes set itself" do
+      it "saves config to the file, implicitly without config file, env lookouts, and excludes set itself" do
         @config[:new_opt] = 'to_file'
         @config.save
         stored = YAML.load_file @file
         assert_equal(@expected_config, stored)
       end
 
-      should "save config to the file, explicitly without excluded entries" do
+      it "saves config to the file, explicitly without excluded entries" do
         @config[@excludes.first] = 'password'
         @config[:new_opt] = 'to_file'
         @config.save
@@ -208,7 +215,7 @@ class ConfigTest < UnitTestCase
         assert_equal(@expected_config, stored)
       end
 
-      should "modifying exclusions after initial read has no effect on config file location and exclusions" do
+      it "modifying exclusions after initial read has no effect on config file location and exclusions" do
         @config[:config_file] = @tmp_dir + '/.tweetwine.another'
         @config[:excludes] << :new_opt
         @config[:new_opt] = 'to_file'
@@ -217,22 +224,17 @@ class ConfigTest < UnitTestCase
         assert_equal(@expected_config, stored)
       end
 
-      should "set config file permissions accessible only to the user when saving" do
+      it "sets config file permissions accessible only to the user when saving" do
         @config.save
         assert_equal 0600, file_mode(@file)
       end
 
-      context "when config file exists" do
-        setup do
-          FileUtils.touch @file
-          @original_mode = 0644
-          File.chmod @original_mode, @file
-        end
-
-        should "not set config file permissions when saving" do
-          @config.save
-          assert_equal @original_mode, file_mode(@file)
-        end
+      it "does not change config file permissions when saving over existing file" do
+        FileUtils.touch @file
+        original_mode = 0644
+        File.chmod original_mode, @file
+        @config.save
+        assert_equal original_mode, file_mode(@file)
       end
     end
   end

data/test/unit/helper.rb

@@ -0,0 +1,108 @@
+# coding: utf-8
+
+require 'helper'
+require 'mocha'
+
+Mocha::Configuration.prevent(:stubbing_non_existent_method)
+
+module Tweetwine::Test
+  module Unit
+    module Assertions
+      # Asserts whether an Enumeration-like object contains all the elements.
+      # Fails unless +actual+ contains the same elements as +expected+,
+      # ignoring the order of the elements.
+      def assert_contains_exactly(expected, actual, msg_diff_size = nil, msg_diff_elems = nil)
+        assert_equal(expected.size, actual.size, message(msg_diff_size) {
+          'Expected %s to be of same size as %s' % [actual.inspect, expected.inspect]
+        })
+        assert(enumerable_minus_each_element(actual, expected).empty?, message(msg_diff_elems) {
+          'Expected %s to contain all the elements of %s' % [actual.inspect, expected.inspect]
+        })
+      end
+
+      # Fails unless +str+ is a full match to +regex+.
+      def assert_full_match(regex, str, msg = nil)
+        match_data = regex.match(str)
+        assert(str == match_data.to_s, message(msg) {
+          'Expected %s to be a full match to %s' % [str, regex.inspect]
+        })
+      end
+
+      # Fails if +str+ is a full match to +regex+.
+      def assert_no_full_match(regex, str, msg = nil)
+        match_data = regex.match(str)
+        assert(str != match_data.to_s, message(msg) {
+          'Expected %s not to be a full match to %s' % [str, regex.inspect]
+        })
+      end
+
+      # Fails unless +fun.call(*args)+ is equal to +expected+ and
+      # +fun.call(*args)+ is equal to +fun.call(*args.reverse)+.
+      def assert_commutative(expected, args, msg_not_expected = nil, msg_not_commutative = nil, &fun)
+        left_args = args
+        left_actual = fun.call(left_args)
+        assert_equal(expected, left_actual, message(msg_not_expected) {
+          'Expected %s, not %s' % [expected.inspect, left_actual.inspect]
+        })
+        right_args = args.reverse
+        right_actual = fun.call(*right_args)
+        assert_equal(left_actual, right_actual, message(msg_not_commutative) {
+          'Expected fun%s => %s to be commutative with fun%s => %s' %
+            [left_args.inspect, left_actual.inspect, right_args.inspect, right_actual.inspect]
+        })
+      end
+
+      private
+
+      def enumerable_minus_each_element(enumerable, elements)
+        remaining = enumerable.dup.to_a
+        elements.each do |e|
+          index = remaining.index(e)
+          remaining.delete_at(index) if index
+        end
+        remaining
+      end
+    end
+
+    module Doubles
+      def mock_config
+        @config = mock('Config')
+        Tweetwine::CLI.stubs(:config).returns(@config)
+      end
+
+      def mock_http
+        @http = mock('Http')
+        Tweetwine::CLI.stubs(:http).returns(@http)
+      end
+
+      def mock_oauth
+        @oauth = mock('OAuth')
+        Tweetwine::CLI.stubs(:oauth).returns(@oauth)
+      end
+
+      def mock_ui
+        @ui = mock('UI')
+        Tweetwine::CLI.stubs(:ui).returns(@ui)
+      end
+
+      def mock_url_shortener
+        @url_shortener = mock('UrlShortener')
+        Tweetwine::CLI.stubs(:url_shortener).returns(@url_shortener)
+      end
+
+      def stub_config(options = {})
+        @config = options
+        Tweetwine::CLI.stubs(:config).returns(@config)
+      end
+    end
+
+    class TestCase < MiniTest::Spec
+      include WebMockIntegration
+      include Tweetwine
+      include Assertions
+      include Doubles
+      include Tweetwine::Test::CommonHelper
+      extend Tweetwine::Test::CommonHelper
+    end
+  end
+end

data/test/unit/http_test.rb

@@ -1,51 +1,51 @@
 # coding: utf-8
 
-require "unit_helper"
+require 'unit/helper'
 
-module Tweetwine::Test
+module Tweetwine::Test::Unit
 
-class HttpTest < UnitTestCase
-  RESPONSE_BODY = "resp"
-  CUSTOM_HEADERS = {'X-Custom' => 'true'}
-  SITE_URL = "https://site.org"
-  LATEST_ARTICLES_URL = "#{SITE_URL}/articles/latest"
-  LATEST_ARTICLES_URL_SORTED = "#{LATEST_ARTICLES_URL}?sort=date"
-  NEW_ARTICLE_URL = "#{SITE_URL}/articles/new"
-  PAYLOAD = {:msg => 'gloomy night'}
+class HttpTest < TestCase
+  RESPONSE_BODY               = "resp"
+  CUSTOM_HEADERS              = {'X-Custom' => 'true'}
+  SITE_URL                    = "https://a-site.org"
+  LATEST_ARTICLES_URL         = "#{SITE_URL}/articles/latest"
+  LATEST_ARTICLES_URL_SORTED  = "#{LATEST_ARTICLES_URL}?sort=date"
+  NEW_ARTICLE_URL             = "#{SITE_URL}/articles/new"
+  PAYLOAD                     = {:msg => 'gloomy night'}
 
-  setup do
+  before do
     mock_ui
     @client = Http::Client.new
     def @client.sleep(*args); end   # speed up tests
   end
 
   %w{http https}.each do |scheme|
-    should "support #{scheme} scheme" do
-      url = "#{scheme}://site.org/"
+    it "supports #{scheme} scheme" do
+      url = "#{scheme}://b-site.org/"
       stub_request(:get, url)
       @client.get(url)
       assert_requested(:get, url)
     end
   end
 
-  should "return response body when successful response" do
+  it "returns response body when successful response" do
     stub_request(:get, LATEST_ARTICLES_URL).to_return(:body => RESPONSE_BODY)
     assert_equal(RESPONSE_BODY, @client.get(LATEST_ARTICLES_URL))
   end
 
-  should "send GET request with query parameters and custom headers" do
+  it "sends GET request with query parameters and custom headers" do
     stub_request(:get, LATEST_ARTICLES_URL_SORTED)
     @client.get(LATEST_ARTICLES_URL_SORTED, CUSTOM_HEADERS)
     assert_requested(:get, LATEST_ARTICLES_URL_SORTED, :headers => CUSTOM_HEADERS)
   end
 
-  should "send POST request with payload and custom headers" do
+  it "sends POST request with payload and custom headers" do
     stub_request(:post, NEW_ARTICLE_URL).with(:body => PAYLOAD, :headers => CUSTOM_HEADERS)
     @client.post(NEW_ARTICLE_URL, PAYLOAD, CUSTOM_HEADERS)
     assert_requested(:post, NEW_ARTICLE_URL, :body => PAYLOAD, :headers => CUSTOM_HEADERS)
   end
 
-  should "store response code and message in HttpError when failed response" do
+  it "stores response code and message in HttpError when failed response" do
     code, message = 501, 'Not Implemented'
     stub_request(:get, LATEST_ARTICLES_URL).to_return(:status => [code, message])
     begin
@@ -59,23 +59,23 @@ class HttpTest < UnitTestCase
   end
 
   [:get, :post].each do |method|
-    should "raise HttpError when failed response to #{method} request" do
+    it "raises HttpError when failed response to #{method} request" do
       stub_request(method, LATEST_ARTICLES_URL).to_return(:status => [500, "Internal Server Error"])
-      assert_raise(HttpError) { @client.send(method, LATEST_ARTICLES_URL) }
+      assert_raises(HttpError) { @client.send(method, LATEST_ARTICLES_URL) }
     end
 
-    should "retry connection upon connection timeout to #{method} request" do
+    it "retries connection upon connection timeout to #{method} request" do
       stub_request(method, LATEST_ARTICLES_URL).to_timeout.then.to_return(:body => RESPONSE_BODY)
       @ui.expects(:warn).with("Could not connect -- retrying in 4 seconds")
       @client.send(method, LATEST_ARTICLES_URL)
       assert_equal(RESPONSE_BODY, @client.send(method, LATEST_ARTICLES_URL))
     end
 
-    should "retry connection a maximum of certain number of times upon connection timeout to #{method} request" do
+    it "retries connection a maximum of certain number of times upon connection timeout to #{method} request" do
       stub_request(method, LATEST_ARTICLES_URL).to_timeout
       io_calls = sequence("IO")
       Http::Client::MAX_RETRIES.times { @ui.expects(:warn).in_sequence(io_calls) }
-      assert_raise(TimeoutError) { @client.send(method, LATEST_ARTICLES_URL) }
+      assert_raises(TimeoutError) { @client.send(method, LATEST_ARTICLES_URL) }
     end
 
     [
@@ -83,22 +83,22 @@ class HttpTest < UnitTestCase
       [Errno::ECONNRESET,   'connection reset'],
       [SocketError,         'socket error']
     ].each do |(error, desc)|
-      should "retry connection upon #{desc} to #{method} request" do
+      it "retries connection upon #{desc} to #{method} request" do
         stub_request(method, LATEST_ARTICLES_URL).to_raise(error).then.to_return(:body => RESPONSE_BODY)
         @ui.expects(:warn).with("Could not connect -- retrying in 4 seconds")
         @client.send(method, LATEST_ARTICLES_URL)
         assert_equal(RESPONSE_BODY, @client.send(method, LATEST_ARTICLES_URL))
       end
 
-      should "retry connection a maximum of certain number of times upon #{desc} to #{method} request" do
+      it "retries connection a maximum of certain number of times upon #{desc} to #{method} request" do
         stub_request(method, LATEST_ARTICLES_URL).to_raise(error)
         io_calls = sequence("IO")
         Http::Client::MAX_RETRIES.times { @ui.expects(:warn).in_sequence(io_calls) }
-        assert_raise(ConnectionError) { @client.send(method, LATEST_ARTICLES_URL) }
+        assert_raises(ConnectionError) { @client.send(method, LATEST_ARTICLES_URL) }
       end
     end
 
-    should "allow access to the #{method} request object just before sending it" do
+    it "allows access to the #{method} request object just before sending it" do
       stub_request(method, LATEST_ARTICLES_URL)
       @client.send(method, LATEST_ARTICLES_URL) do |_, request|
         request['X-Quote'] = 'You monster.'
@@ -107,7 +107,7 @@ class HttpTest < UnitTestCase
     end
   end
 
-  context "for proxy support" do
+  describe "for proxy support" do
     [
       ['proxy.net',             'proxy.net', 8080],
       ['http://proxy.net',      'proxy.net', 8080],
@@ -115,7 +115,7 @@ class HttpTest < UnitTestCase
       ['http://proxy.net:8080', 'proxy.net', 8080],
       ['http://proxy.net:8182', 'proxy.net', 8182]
     ].each do |proxy_url, expected_host, expected_port|
-      should "support proxy, when its URL is #{proxy_url}" do
+      it "supports proxy, when its URL is #{proxy_url}" do
         proxy = Http::Client.new(:http_proxy => proxy_url)
         net_http = proxy.instance_variable_get(:@http)
         assert(net_http.proxy_class?)
@@ -124,49 +124,49 @@ class HttpTest < UnitTestCase
       end
     end
 
-    should "raise CommandLineError if given invalid port" do
-      assert_raise(CommandLineError) do
+    it "raises CommandLineError if given invalid port" do
+      assert_raises(CommandLineError) do
         Http::Client.new(:http_proxy => 'http://proxy.net:asdf')
       end
     end
   end
 
-  context "when using client as resource" do
-    setup do
+  describe "when using client as resource" do
+    before do
       @resource = @client.as_resource(SITE_URL)
     end
 
-    should "send GET request with custom headers to the base URL" do
+    it "sends GET request with custom headers to the base URL" do
       stub_request(:get, SITE_URL)
       @resource.get(CUSTOM_HEADERS)
       assert_requested(:get, SITE_URL, :headers => CUSTOM_HEADERS)
     end
 
-    should "send POST request with payload and custom headers to the base URL" do
+    it "sends POST request with payload and custom headers to the base URL" do
       stub_request(:post, SITE_URL).with(:body => PAYLOAD, :headers => CUSTOM_HEADERS)
       @resource.post(PAYLOAD, CUSTOM_HEADERS)
       assert_requested(:post, SITE_URL, :body => PAYLOAD, :headers => CUSTOM_HEADERS)
     end
 
-    context "when constructing new resource from the original as a sub-URL" do
-      setup do
+    describe "when constructing new resource from the original as a sub-URL" do
+      before do
         @news_resource = @resource['news']
         @expected_news_url = "#{SITE_URL}/news"
       end
 
-      should "send GET request with custom headers to the sub-URL" do
+      it "sends GET request with custom headers to the sub-URL" do
         stub_request(:get, @expected_news_url)
         @news_resource.get(CUSTOM_HEADERS)
         assert_requested(:get, @expected_news_url, :headers => CUSTOM_HEADERS)
       end
 
-      should "send POST request with payload and custom headers to the sub-URL" do
+      it "sends POST request with payload and custom headers to the sub-URL" do
         stub_request(:post, @expected_news_url).with(:body => PAYLOAD, :headers => CUSTOM_HEADERS)
         @news_resource.post(PAYLOAD, CUSTOM_HEADERS)
         assert_requested(:post, @expected_news_url, :body => PAYLOAD, :headers => CUSTOM_HEADERS)
       end
 
-      should "further construct a new resource from the original" do
+      it "further constructs a new resource from the original" do
         news_resource = @news_resource['top']
         expected_url = "#{SITE_URL}/news/top"
         stub_request(:get, expected_url)

data/test/unit/oauth_test.rb

@@ -1,22 +1,21 @@
 # coding: utf-8
 
-require "unit_helper"
-require "fixture/oauth"
+require 'unit/helper'
+require 'fixture/oauth'
+require 'net/http'
 
-require "net/http"
+module Tweetwine::Test::Unit
 
-module Tweetwine::Test
+class OAuthTest < TestCase
+  include Test::Fixture::OAuth
 
-class OAuthTest < UnitTestCase
-  include Fixture::OAuth
-
-  setup do
+  before do
     mock_http
     mock_ui
     @oauth = OAuth.new
   end
 
-  should "authorize with PIN code so that request can be signed" do
+  it "authorizes with PIN code so that request can be signed" do
     expect_complete_oauth_dance
     @oauth.authorize
     connection, request = *fake_http_connection_and_request
@@ -25,26 +24,26 @@ class OAuthTest < UnitTestCase
     assert_match(/oauth_token="#{ACCESS_TOKEN_KEY}"/, request['Authorization'])
   end
 
-  should "raise AuthorizationError if OAuth dance fails due to HTTP 4xx response" do
+  it "raises AuthorizationError if OAuth dance fails due to HTTP 4xx response" do
     @http.expects(:post).
       with(REQUEST_TOKEN_URL).
       raises(HttpError.new(401, 'Unauthorized'))
-    assert_raise(AuthorizationError) { @oauth.authorize }
+    assert_raises(AuthorizationError) { @oauth.authorize }
   end
 
-  should "pass other exceptions than due to HTTP 4xx responses through" do
+  it "passes other exceptions than due to HTTP 4xx responses through" do
     @http.expects(:post).
       with(REQUEST_TOKEN_URL).
       raises(HttpError.new(503, 'Service Unavailable'))
-    assert_raise(HttpError) { @oauth.authorize }
+    assert_raises(HttpError) { @oauth.authorize }
   end
 
-  context "when access token is known" do
-    setup do
+  describe "when access token is known" do
+    before do
       @oauth = OAuth.new(Obfuscate.write("#{ACCESS_TOKEN_KEY}:2"))
     end
 
-    should "sign request with it" do
+    it "signs request with it" do
       connection, request = *fake_http_connection_and_request
       @oauth.request_signer.call(connection, request)
       assert_match(/^OAuth /, request['Authorization'])