tweetwine 0.2.12 → 0.3.0

data/test/retrying_http_test.rb

@@ -1,147 +0,0 @@
-# coding: utf-8
-
-require "test_helper"
-require "rest_client"
-
-class Object
-  def sleep(timeout); end   # speed up tests
-end
-
-module Tweetwine
-
-class RetryingHttpModuleTest < TweetwineTestCase
-  context "When using HTTP proxy" do
-    setup do
-      RetryingHttp.proxy = "http://proxy.net:8080"
-    end
-
-    should "pass HTTP proxy configuration to RestClient" do
-      assert_equal "http://proxy.net:8080", RestClient.proxy
-    end
-
-    teardown do
-      RetryingHttp.proxy = nil
-    end
-  end
-end
-
-class RetryingHttpClientTest < TweetwineTestCase
-  context "A Client instance" do
-    setup do
-      @io = mock()
-      @client = RetryingHttp::Client.new(@io)
-    end
-
-    should "wrap RestClient.get" do
-      RestClient.expects(:get).with("https://site.org")
-      @client.get("https://site.org")
-    end
-
-    should "wrap RestClient.post" do
-      RestClient.expects(:post).with("https://site.org", { :key => "value" })
-      @client.post("https://site.org", { :key => "value" })
-    end
-
-    should "raise HttpError for an invalid request" do
-      RestClient.expects(:get).with("https://charlie:42@authorization.org").raises(RestClient::Unauthorized)
-      assert_raise(HttpError) { @client.get("https://charlie:42@authorization.org") }
-    end
-
-    should "raise HttpError when connection cannot be established" do
-      RestClient.expects(:get).with("https://unreachable.org").raises(Errno::ECONNABORTED)
-      assert_raise(HttpError) { @client.get("https://unreachable.org") }
-    end
-
-    should "raise HttpError when host cannot be resolved" do
-      RestClient.expects(:get).with("https://unresolved.org").raises(SocketError)
-      assert_raise(HttpError) { @client.get("https://unresolved.org") }
-    end
-
-    [Errno::ECONNRESET, RestClient::RequestTimeout].each do |error_class|
-      should "retry connection upon connection reset, case #{error_class}" do
-        retrying_calls = sequence("Retrying Client calls")
-        RestClient.expects(:get).with("https://moderate.traffic.org").in_sequence(retrying_calls).raises(error_class)
-        RestClient.expects(:get).with("https://moderate.traffic.org").in_sequence(retrying_calls)
-        @io.expects(:warn).with("Could not connect -- retrying in 4 seconds")
-        @client.get("https://moderate.traffic.org")
-      end
-
-      should "retry connection a maximum of certain number of times, case #{error_class}" do
-        retrying_calls = sequence("Retrying Client calls")
-        io_calls = sequence("IO")
-        (RetryingHttp::Client::MAX_RETRIES + 1).times do
-          RestClient.expects(:get).with("https://unresponsive.org").in_sequence(retrying_calls).raises(error_class)
-        end
-        RetryingHttp::Client::MAX_RETRIES.times do
-          @io.expects(:warn).in_sequence(io_calls)
-        end
-        assert_raise(HttpError) { @client.get("https://unresponsive.org") }
-      end
-    end
-
-    should "return a resource with IO inherited from the client" do
-      resource = @client.as_resource("http://foo.bar")
-      assert_equal(@io, resource.io)
-    end
-  end
-end
-
-class RetryingHttpResourceTest < TweetwineTestCase
-  context "A Resource instance" do
-    setup do
-      @io = mock()
-      @wrapped = mock()
-      @resource = RetryingHttp::Resource.new(@wrapped)
-      @resource.io = @io
-    end
-
-    should "allow wrapping RestClient::Resource#get" do
-      @wrapped.expects(:get).with("https://site.org")
-      @resource.get("https://site.org")
-    end
-
-    should "allow wrapping RestClient::Resource#post" do
-      @wrapped.expects(:post).with("https://site.org", { :key => "value" })
-      @resource.post("https://site.org", { :key => "value" })
-    end
-
-    should "raise HttpError for an invalid request" do
-      @wrapped.expects(:get).raises(RestClient::Unauthorized)
-      assert_raise(HttpError) { @resource.get }
-    end
-
-    should "raise HttpError when connection cannot be established" do
-      @wrapped.expects(:get).raises(Errno::ECONNABORTED)
-      assert_raise(HttpError) { @resource.get }
-    end
-
-    should "raise HttpError when host cannot be resolved" do
-      @wrapped.expects(:get).raises(SocketError)
-      assert_raise(HttpError) { @resource.get }
-    end
-
-    [Errno::ECONNRESET, RestClient::RequestTimeout].each do |error_class|
-      should "retry connection upon connection reset, case #{error_class}" do
-        retrying_calls = sequence("Retrying Resource calls")
-        @wrapped.expects(:get).in_sequence(retrying_calls).raises(error_class)
-        @wrapped.expects(:get).in_sequence(retrying_calls)
-        @io.expects(:warn).with("Could not connect -- retrying in 4 seconds")
-        @resource.get
-      end
-
-      should "retry connection a maximum of certain number of times, case #{error_class}" do
-        retrying_calls = sequence("Retrying Resource calls")
-        io_calls = sequence("IO")
-        (RetryingHttp::Resource::MAX_RETRIES + 1).times do
-          @wrapped.expects(:get).in_sequence(retrying_calls).raises(error_class)
-        end
-        RetryingHttp::Resource::MAX_RETRIES.times do
-          @io.expects(:warn).in_sequence(io_calls)
-        end
-        assert_raise(HttpError) { @resource.get }
-      end
-    end
-  end
-end
-
-end

data/test/startup_config_test.rb

@@ -1,162 +0,0 @@
-# coding: utf-8
-
-require "test_helper"
-
-module Tweetwine
-
-class StartupConfigTest < TweetwineTestCase
-  TEST_CONFIG_FILE = Helper.fixture_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([:cmd], :cmd) }
-      end
-
-      should "require the default command to be a supported command" do
-        assert_raise(ArgumentError) { StartupConfig.new([:cmd_a], :cmd_b) }
-        assert_nothing_raised { StartupConfig.new([:cmd_a], :cmd_a) }
-      end
-
-      should "allow passing default options" do
-        opts = {:opt => "foo"}
-        config = StartupConfig.new([:cmd_a], :cmd_a, opts)
-        assert_equal opts, config.options
-      end
-    end
-
-    context "at runtime" do
-      setup do
-        @config = StartupConfig.new(
-          [:default_action, :another_action],
-          :default_action,
-          {:defopt => 42})
-      end
-
-      should "use the default command when given no command as a cmdline argument" do
-        @config.parse
-        assert_equal :default_action, @config.command
-      end
-
-      should "pass supported commands" 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 "raise ArgumentError if given command is not supported" do
-        assert_raise(ArgumentError) do
-          @config.parse(%w{unknown_action}) { |args| {} }
-        end
-      end
-
-      context "when given cmdline args and no config file and no environment variables" do
-        setup do
-          @cmd_args = %w{--opt bar --another_opt baz another_action left overs}
-          @config.parse(@cmd_args) do |args|
-            args.slice!(0..3)
-            {:defopt => 56, :nopt => "baz"}
-          end
-        end
-
-        should "have the parsed option defined" do
-          assert_equal "baz", @config.options[:nopt]
-        end
-
-        should "override the default value for the option given as a cmdline arg" do
-          assert_equal 56, @config.options[:defopt]
-        end
-
-        should "parse cmdline args before the command" do
-          assert_equal({:defopt => 56, :nopt => "baz"}, @config.options)
-        end
-
-        should "identify the next argument after cmdline args as the command" do
-          assert_equal :another_action, @config.command
-        end
-
-        should "leave remaining args to be consumed by the command" do
-          assert_equal %w{left overs}, @cmd_args
-        end
-      end
-
-      context "when given a config file and no cmdline args and no environment variables" do
-        setup do
-          @config.parse([], TEST_CONFIG_FILE)
-        end
-
-        should "have the parsed option defined" do
-          assert_equal false, @config.options[:colors]
-        end
-
-        should "override the default value for the option given from the config file" do
-          assert_equal 78, @config.options[:defopt]
-        end
-      end
-
-      context "when given an environment variable and no cmdline args no config file" do
-        setup do
-          ENV['colors'] = "baba"
-          ENV['defopt'] = "zaza"
-          ENV['blank'] = ""
-          @config.parse([], nil, [:colors, :defopt])
-        end
-
-        should "have the parsed option defined" do
-          assert_equal "baba", @config.options[:colors]
-        end
-
-        should "override default value for the option given as an environment variable" do
-          assert_equal "zaza", @config.options[:defopt]
-        end
-
-        should "not pass blank environment variable" do
-          assert_equal nil, @config.options[:blank]
-        end
-
-        teardown do
-          ENV['colors'] = ENV['defopt'] = ENV['blank'] = nil
-        end
-      end
-
-      context "when given an option as a cmdline option and in a config file and as an environment variable" do
-        setup do
-          @config.parse(%w{--colors}, TEST_CONFIG_FILE, [:colors, :defopt]) do |args|
-            args.clear
-            {:defopt => 56, :colors => true}
-          end
-        end
-
-        should "the command line option should override all other option sources" do
-          assert_equal true, @config.options[:colors]
-          assert_equal 56, @config.options[:defopt]
-        end
-      end
-
-      context "when given an option from a config file and as an environment variable" do
-        setup do
-          ENV['colors'] = "baba"
-          ENV['defopt'] = "zaza"
-          @config.parse(%w{}, TEST_CONFIG_FILE, [:colors, :defopt]) do |args|
-            args.clear
-            {}
-          end
-        end
-
-        should "the config file option should override environment variable" do
-          assert_equal false, @config.options[:colors]
-          assert_equal 78, @config.options[:defopt]
-        end
-
-        teardown do
-          ENV['colors'] = ENV['defopt'] = nil
-        end
-      end
-    end
-  end
-end
-
-end