tweetwine 0.2.12 → 0.3.0

data/test/character_encoding_test.rb

@@ -0,0 +1,87 @@
+# coding: utf-8
+
+require "test_helper"
+
+module Tweetwine::Test
+
+class CharacterEncodingTest < UnitTestCase
+  if "".respond_to?(:encode)
+    context "when transcoding to UTF-8 when String supports encoding" do
+      should "transcode string to UTF-8" do
+        str_utf8 = "groß résumé"
+        str_latin1 = str_utf8.encode('ISO-8859-1')
+        assert_equal str_utf8, CharacterEncoding.to_utf8(str_latin1)
+      end
+
+      should "raise exception if result is invalid UTF-8" do
+        assert_raise(TranscodeError) { CharacterEncoding.to_utf8("\xa4") }
+      end
+    end
+  else
+    context "when transcoding to UTF-8 when String does not support encoding" do
+      # résumé
+      RESUME_EUC    = "r\x8F\xAB\xB1sum\x8F\xAB\xB1"
+      RESUME_LATIN1 = "r\xe9sum\xe9"
+      RESUME_UTF8   = "r\xc3\xa9sum\xc3\xa9"
+
+      # ホーム ("home" in Japanese)
+      HOME_SJIS     = "\x83\x7a\x81\x5b\x83\x80"
+      HOME_UTF8     = "\xe3\x83\x9b\xe3\x83\xbc\xe3\x83\xa0"
+
+      setup do
+        Tweetwine::CharacterEncoding.forget_guess
+      end
+
+      [
+        ['EUC',   RESUME_EUC, RESUME_UTF8],
+        ['SJIS',  HOME_SJIS,  HOME_UTF8]
+      ].each do |(kcode, original, expected)|
+        should "transcode with Iconv, guessing first from $KCODE, case #{kcode}" do
+          tmp_kcode(kcode) do
+            assert_equal expected, CharacterEncoding.to_utf8(original)
+          end
+        end
+      end
+
+      [
+        ['latin1',    RESUME_LATIN1,  RESUME_UTF8],
+        ['EUC-JP',    RESUME_EUC,     RESUME_UTF8],
+        ['SHIFT_JIS', HOME_SJIS,      HOME_UTF8]
+      ].each do |(lang, original, expected)|
+        should "transcode with Iconv, guessing second from envar $LANG, case #{lang}" do
+          tmp_kcode('NONE') do
+            tmp_env(:LANG => lang) do
+              assert_equal expected, CharacterEncoding.to_utf8(original)
+            end
+          end
+        end
+      end
+
+      should "pass string as is, if guess is UTF-8, case $KCODE is UTF-8" do
+        tmp_kcode('UTF8') do
+          assert_same RESUME_UTF8, CharacterEncoding.to_utf8(RESUME_UTF8)
+        end
+      end
+
+      %w{utf8 UTF-8 en_US.UTF-8 fi_FI.utf-8 fi_FI.utf8}.each do |lang|
+        should "pass string as is, if guess is UTF-8, case envar $LANG is '#{lang}'" do
+          tmp_kcode('NONE') do
+            tmp_env(:LANG => lang) do
+              assert_same RESUME_UTF8, CharacterEncoding.to_utf8(RESUME_UTF8)
+            end
+          end
+        end
+      end
+
+      should "raise exception if conversion cannot be done because we couldn't guess external encoding" do
+        tmp_kcode('NONE') do
+          tmp_env(:LANG => nil) do
+            assert_raise(Tweetwine::TranscodeError) { CharacterEncoding.to_utf8(RESUME_LATIN1) }
+          end
+        end
+      end
+    end
+  end
+end
+
+end

data/test/cli_test.rb

@@ -1,18 +1,31 @@
 # coding: utf-8
 
 require "test_helper"
+require "stringio"
 
-module Tweetwine
+module Tweetwine::Test
 
-class CLITest < TweetwineTestCase
-  context "A CLI, upon initialization" do
+# See +example+ directory for integration tests.
+class CLITest < UnitTestCase
+  context "for initialization" do
     should "disallow using #new to create a new instance" do
-      assert_raise(NoMethodError) { CLI.new("-v", "test", "") {} }
+      assert_raise(NoMethodError) { CLI.new }
+    end
+
+    should "allow defining same option multiple times, last value winning" do
+      winning_option_value = 'second'
+      start_cli %W{-f first -f #{winning_option_value} -v}
+      assert_equal winning_option_value, CLI.config[:config_file]
     end
   end
 
-  # Other unit tests are meaningless. See /example directory for tests
-  # about the functionality of the application.
+  private
+
+  def start_cli(args)
+    output = StringIO.new
+    CLI.start(args, { :out => output })
+    output.string.split("\n")
+  end
 end
 
 end

data/test/config_test.rb

@@ -0,0 +1,244 @@
+# coding: utf-8
+
+require "test_helper"
+
+require "fileutils"
+require "tempfile"
+require "yaml"
+
+module Tweetwine::Test
+
+class ConfigTest < UnitTestCase
+  CONFIG_FILE = Helper.fixture_file("test_config.yaml")
+
+  context "when given command line arguments, no environment variables, no config file" do
+    setup do
+      @args = %w{--opt cmd_opt --defopt cmd_defopt left overs}
+      default_config = {:defopt => 'defopt'}
+      @config = Config.read(@args, default_config) do |args|
+        args.slice!(0..3)
+        {:opt => 'cmd_opt', :defopt => 'cmd_defopt'}
+      end
+    end
+
+    should "have option defined from command line" do
+      assert_equal 'cmd_opt', @config[:opt]
+    end
+
+    should "override option default value from command line" do
+      assert_equal 'cmd_defopt', @config[:defopt]
+    end
+
+    should "leave 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
+      ENV['opt']    = 'env_opt'
+      ENV['defopt'] = 'env_defopt'
+      ENV['envopt'] = 'env_envopt'
+      @args = %w{--opt cmd_opt}
+      default_config = {:defopt => 'defopt', :env_lookouts => [:defopt, :envopt, :opt]}
+      @config = Config.read(@args, default_config) do |args|
+        args.slice!(0..1)
+        {:opt => 'cmd_opt'}
+      end
+    end
+
+    teardown do
+      ENV['opt']    = nil
+      ENV['defopt'] = nil
+      ENV['envopt'] = nil
+    end
+
+    should "have option defined from environment variable" do
+      assert_equal 'env_envopt', @config[:envopt]
+    end
+
+    should "override 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
+      assert_equal 'env_defopt', @config[:defopt]
+    end
+  end
+
+  context "when given command line arguments, no environment variables, config file" do
+    setup do
+      @args = %w{--opt cmd_opt}
+      default_config = {:config_file => CONFIG_FILE, :defopt => 'defopt'}
+      @config = Config.read(@args, default_config) do |args|
+        args.slice!(0..1)
+        {:opt => 'cmd_opt'}
+      end
+    end
+
+    should "have option defined from config file" do
+      assert_equal 'file_fileopt', @config[:fileopt]
+    end
+
+    should "override 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
+      assert_equal 'file_defopt', @config[:defopt]
+    end
+  end
+
+  context "when given command line arguments, environment variables, config file" do
+    setup do
+      @args = %w{--opt2 cmd_opt2}
+      ENV['opt']  = 'env_opt'
+      ENV['opt2'] = 'env_opt2'
+      @config = Config.read(@args, :config_file => CONFIG_FILE, :env_lookouts => [:opt, :opt2]) do |args|
+        args.slice!(0..2)
+        {:opt2 => 'cmd_opt2'}
+      end
+    end
+
+    teardown do
+      ENV['opt']  = nil
+      ENV['opt2'] = nil
+    end
+
+    should "override 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
+      assert_equal 'cmd_opt2', @config[:opt2]
+    end
+  end
+
+  context "when handling command line arguments without parser" do
+    setup 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
+    end
+
+    should "ignore 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
+      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
+    end
+
+    should "consider only specified environment variables that are nonempty" do
+      assert_equal 'env_visible', @config[:visible]
+    end
+
+    should "not consider empty environment variables" do
+      assert_equal nil, @config[:empty]
+    end
+
+    should "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
+      @args = ['-f', CONFIG_FILE]
+      @config = Config.read(@args, {}) do
+        @args.slice!(0..1)
+        {:config_file => CONFIG_FILE}
+      end
+      assert_equal %w{config_file defopt fileopt opt}, @config.keys.map { |k| k.to_s }.sort
+      assert_equal 'file_defopt', @config[:defopt]
+    end
+
+    should "raise exception when trying to save and no config file is specified" do
+      @config = Config.read()
+      assert_raise(RuntimeError) { @config.save }
+    end
+
+    context "when config file does not exist" do
+      setup do
+        @tmp_dir = Dir.mktmpdir
+        @file = @tmp_dir + '/.tweetwine'
+        @excludes = [:secret]
+        @default_config = {:config_file => @file, :env_lookouts => [:envopt], :excludes => @excludes}
+        @config = Config.read([], @default_config)
+        @expected_config = {'new_opt' => 'to_file'}
+      end
+
+      teardown do
+        FileUtils.remove_entry_secure @tmp_dir
+      end
+
+      should "ignore nonexisting config file for initial read" do
+        assert_contains_in_order(@default_config.keys, @config.keys) do |a, b|
+          # On Ruby 1.8, Symbol does not have #<=> operator for comparison.
+          a.to_s <=> b.to_s
+        end
+      end
+
+      should "save 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
+        @config[@excludes.first] = 'password'
+        @config[:new_opt] = 'to_file'
+        @config.save
+        stored = YAML.load_file @file
+        assert_equal(@expected_config, stored)
+      end
+
+      should "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'
+        @config.save
+        stored = YAML.load_file @file
+        assert_equal(@expected_config, stored)
+      end
+
+      should "set 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
+      end
+    end
+  end
+end
+
+end

data/test/fixture/oauth.rb

@@ -0,0 +1,21 @@
+# coding: utf-8
+
+module Tweetwine::Test
+
+module Fixture
+  module OAuth
+    METHOD = :post
+    REQUEST_TOKEN_KEY = 'ManManManManManManManManManManManManManM'
+    REQUEST_TOKEN_SECRET = '3x3x3x3x3x3x3x3x3x3x3x3x3x3x3x3x3x3x3x3x3'
+    REQUEST_TOKEN_RESPONSE = "oauth_token=#{REQUEST_TOKEN_KEY}&oauth_token_secret=#{REQUEST_TOKEN_SECRET}&oauth_callback_confirmed=true"
+    REQUEST_TOKEN_URL = 'https://api.twitter.com/oauth/request_token'
+    ACCESS_TOKEN_KEY = '111111111-XyzXyzXyzXyzXyzXyzXyzXyzXyzXyzXyzXyzXyzX'
+    ACCESS_TOKEN_SECRET = '4x4x4x4x4x4x4x4x4x4x4x4x4x4x4x4x4x4x4x4x4x'
+    ACCESS_TOKEN_RESPONSE = "oauth_token=#{ACCESS_TOKEN_KEY}&oauth_token_secret=#{ACCESS_TOKEN_SECRET}&user_id=42&screen_name=fooman"
+    ACCESS_TOKEN_URL = 'https://api.twitter.com/oauth/access_token'
+    AUTHORIZE_URL = "https://api.twitter.com/oauth/authorize?oauth_token=#{REQUEST_TOKEN_KEY}"
+    PIN = '12345678'
+  end
+end
+
+end

data/test/fixture/test_config.yaml

@@ -1,4 +1,4 @@
-username: foo
-password: bar
-colors: false
-defopt: 78
+---
+opt: file_opt
+fileopt: file_fileopt
+defopt: file_defopt

data/test/http_test.rb

@@ -0,0 +1,199 @@
+# coding: utf-8
+
+require "test_helper"
+
+module Tweetwine::Test
+
+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'}
+
+  setup do
+    stub_sleep
+    mock_ui
+    @client = Http::Client.new
+  end
+
+  teardown do
+    restore_sleep
+  end
+
+  %w{http https}.each do |scheme|
+    should "support #{scheme} scheme" do
+      url = "#{scheme}://site.org/"
+      stub_request(:get, url)
+      @client.get(url)
+      assert_requested(:get, url)
+    end
+  end
+
+  should "return 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
+    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
+    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
+    code, message = 501, 'Not Implemented'
+    stub_request(:get, LATEST_ARTICLES_URL).to_return(:status => [code, message])
+    begin
+      @client.send(:get, LATEST_ARTICLES_URL)
+    rescue HttpError => e
+      assert_equal(code, e.http_code)
+      assert_equal(message, e.http_message)
+    else
+      flunk 'Should have raised HttpError'
+    end
+  end
+
+  [:get, :post].each do |method|
+    should "raise 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) }
+    end
+
+    should "retry 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
+      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) }
+    end
+
+    [
+      [Errno::ECONNABORTED, 'abort'],
+      [Errno::ECONNRESET,   'reset']
+    ].each do |error, desc|
+      should "retry connection upon connection #{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 connection #{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) }
+      end
+    end
+
+    should "allow 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.'
+      end
+      assert_requested(method, LATEST_ARTICLES_URL, :headers => {'X-Quote' => 'You monster.'})
+    end
+  end
+
+  context "for proxy support" do
+    [
+      ['proxy.net',             'proxy.net', 8080],
+      ['http://proxy.net',      'proxy.net', 8080],
+      ['https://proxy.net',     'proxy.net', 8080],
+      ['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
+        proxy = Http::Client.new(:http_proxy => proxy_url)
+        net_http = proxy.instance_variable_get(:@http)
+        assert(net_http.proxy_class?)
+        assert_equal(expected_host, net_http.instance_variable_get(:@proxy_address))
+        assert_equal(expected_port, net_http.instance_variable_get(:@proxy_port))
+      end
+    end
+
+    should "raise CommandLineError if given invalid port" do
+      assert_raise(CommandLineError) do
+        Http::Client.new(:http_proxy => 'http://proxy.net:asdf')
+      end
+    end
+  end
+
+  context "when using client as resource" do
+    setup do
+      @resource = @client.as_resource(SITE_URL)
+    end
+
+    should "send 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
+      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
+        @news_resource = @resource['news']
+        @expected_news_url = "#{SITE_URL}/news"
+      end
+
+      should "send 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
+        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
+        news_resource = @news_resource['top']
+        expected_url = "#{SITE_URL}/news/top"
+        stub_request(:get, expected_url)
+        news_resource.get(CUSTOM_HEADERS)
+        assert_requested(:get, expected_url, :headers => CUSTOM_HEADERS)
+      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/oauth_test.rb

@@ -0,0 +1,77 @@
+# coding: utf-8
+
+require "test_helper"
+require "fixture/oauth"
+require "net/http"
+
+module Tweetwine::Test
+
+class OAuthTest < UnitTestCase
+  include Fixture::OAuth
+
+  setup do
+    mock_http
+    mock_ui
+    @oauth = OAuth.new
+  end
+
+  should "authorize with PIN code so that request can be signed" do
+    expect_complete_oauth_dance
+    @oauth.authorize
+    connection, request = *fake_http_connection_and_request
+    @oauth.request_signer.call(connection, request)
+    assert_match(/^OAuth /, request['Authorization'])
+    assert_match(/oauth_token="#{ACCESS_TOKEN_KEY}"/, request['Authorization'])
+  end
+
+  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'))
+    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'))
+    assert_raise(HttpError) { @oauth.authorize }
+  end
+
+  context "when access token is known" do
+    setup do
+      @oauth = OAuth.new(Obfuscate.write("#{ACCESS_TOKEN_KEY}:2"))
+    end
+
+    should "sign request with it" do
+      connection, request = *fake_http_connection_and_request
+      @oauth.request_signer.call(connection, request)
+      assert_match(/^OAuth /, request['Authorization'])
+      assert_match(/oauth_token="#{ACCESS_TOKEN_KEY}"/, request['Authorization'])
+    end
+  end
+
+  private
+
+  def expect_complete_oauth_dance
+    @http.expects(:post).
+        with(REQUEST_TOKEN_URL).
+        returns(REQUEST_TOKEN_RESPONSE)
+    @ui.expects(:info).
+        with("Please authorize: #{AUTHORIZE_URL}")
+    @ui.expects(:prompt).
+        with('Enter PIN').
+        returns(PIN)
+    @http.expects(:post).
+        with(ACCESS_TOKEN_URL).
+        returns(ACCESS_TOKEN_RESPONSE)
+  end
+
+  def fake_http_connection_and_request
+    connection = stub(:address => 'api.twitter.com', :port => 443)
+    request = Net::HTTP::Post.new('1/statuses/home_timeline.json')
+    [connection, request]
+  end
+end
+
+end

data/test/obfuscate_test.rb

@@ -0,0 +1,16 @@
+# coding: utf-8
+
+require "test_helper"
+
+module Tweetwine::Test
+
+class ObfuscateTest < UnitTestCase
+  include Obfuscate
+
+  should "obfuscate symmetrically" do
+    str = 'hey, jack'
+    assert_equal(str, obfuscate(obfuscate(str)))
+  end
+end
+
+end