tilia-http 4.1.0

data/test/http/auth/digest_test.rb

@@ -0,0 +1,141 @@
+require 'digest'
+require 'test_helper'
+
+module Tilia
+  module Http
+    class DigestTest < Minitest::Test
+      REALM = 'SabreDAV unittest'
+
+      def setup
+        @response = Response.new
+        @request = Request.new
+        @auth = Auth::Digest.new(REALM, @request, @response)
+      end
+
+      def uniqid
+        Digest::SHA1.hexdigest((Time.now.to_f + rand).to_s)[0..14]
+      end
+
+      def get_server_tokens(qop = Auth::Digest::QOP_AUTH)
+        @auth.require_login
+
+        case qop
+        when Auth::Digest::QOP_AUTH
+          qopstr = 'auth'
+        when Auth::Digest::QOP_AUTHINT
+          qopstr = 'auth-int'
+        else
+          qopstr = 'auth,auth-int'
+        end
+
+        test_result = @response.header('WWW-Authenticate') =~ /Digest realm="#{REALM}",qop="#{qopstr}",nonce="([0-9a-f]*)",opaque="([0-9a-f]*)"/
+
+        assert(test_result, "The WWW-Authenticate response didn't match our pattern. We received: #{@response.header('WWW-Authenticate')}")
+
+        nonce = Regexp.last_match[1]
+        opaque = Regexp.last_match[2]
+
+        # Reset our environment
+        setup
+        @auth.qop = qop
+
+        [nonce, opaque]
+      end
+
+      def test_digest
+        (nonce, opaque) = get_server_tokens
+
+        username = 'admin'
+        password = '12345'
+        nc = '00002'
+        cnonce = uniqid
+
+        digest_hash = Digest::MD5.hexdigest(
+          "#{Digest::MD5.hexdigest("#{username}:#{REALM}:#{password}")}:#{nonce}:#{nc}:#{cnonce}:auth:#{Digest::MD5.hexdigest('GET:/')}"
+        )
+
+        @request.method = 'GET'
+        @request.update_header('Authorization', "Digest username=\"#{username}\", realm=\"#{REALM}\", nonce=\"#{nonce}\", uri=\"/\", response=\"#{digest_hash}\", opaque=\"#{opaque}\", qop=auth,nc=#{nc},cnonce=\"#{cnonce}\"")
+
+        @auth.init
+
+        assert_equal(username, @auth.username)
+        assert_equal(REALM, @auth.realm)
+        assert(@auth.validate_a1(Digest::MD5.hexdigest("#{username}:#{REALM}:#{password}")), 'Authentication is deemed invalid through validateA1')
+        assert(@auth.validate_password(password), 'Authentication is deemed invalid through validatepassword')
+      end
+
+      def test_invalid_digest
+        (nonce, opaque) = get_server_tokens
+
+        username = 'admin'
+        password = '12345'
+        nc = '00002'
+        cnonce = uniqid
+
+        digest_hash = Digest::MD5.hexdigest(
+          "#{Digest::MD5.hexdigest("#{username}:#{REALM}:#{password}")}:#{nonce}:#{nc}:#{cnonce}:auth:#{Digest::MD5.hexdigest('GET:/')}"
+        )
+
+        @request.method = 'GET'
+        @request.update_header('Authorization', "Digest username=\"#{username}\", realm=\"#{REALM}\", nonce=\"#{nonce}\", uri=\"/\", response=\"#{digest_hash}\", opaque=\"#{opaque}\", qop=auth,nc=#{nc},cnonce=\"#{cnonce}\"")
+
+        @auth.init
+
+        refute(@auth.validate_a1(Digest::MD5.hexdigest("#{username}:#{REALM}:#{password}randomness")), 'Authentication is deemed invalid through validateA1')
+      end
+
+      def test_invalid_digest2
+        @request.method = 'GET'
+        @request.update_header('Authorization', 'basic blablabla')
+
+        @auth.init
+        refute(@auth.validate_a1(Digest::MD5.hexdigest('user:realm:password')))
+      end
+
+      def test_digest_auth_int
+        @auth.qop = Auth::Digest::QOP_AUTHINT
+        (nonce, opaque) = get_server_tokens(Auth::Digest::QOP_AUTHINT)
+
+        username = 'admin'
+        password = '12345'
+        nc = '00003'
+        cnonce = uniqid
+
+        digest_hash = Digest::MD5.hexdigest(
+          "#{Digest::MD5.hexdigest("#{username}:#{REALM}:#{password}")}:#{nonce}:#{nc}:#{cnonce}:auth-int:#{Digest::MD5.hexdigest('POST:/:' + Digest::MD5.hexdigest('body'))}"
+        )
+
+        @request.method = 'POST'
+        @request.update_header('Authorization', "Digest username=\"#{username}\", realm=\"#{REALM}\", nonce=\"#{nonce}\", uri=\"/\", response=\"#{digest_hash}\", opaque=\"#{opaque}\", qop=auth-int,nc=#{nc},cnonce=\"#{cnonce}\"")
+        @request.body = 'body'
+
+        @auth.init
+
+        assert(@auth.validate_a1(Digest::MD5.hexdigest("#{username}:#{REALM}:#{password}")), 'Authentication is deemed invalid through validateA1')
+      end
+
+      def test_digest_auth_both
+        @auth.qop = Auth::Digest::QOP_AUTHINT | Auth::Digest::QOP_AUTH
+        (nonce, opaque) = get_server_tokens(Auth::Digest::QOP_AUTHINT | Auth::Digest::QOP_AUTH)
+
+        username = 'admin'
+        password = '12345'
+        nc = '00003'
+        cnonce = uniqid
+
+        digest_hash = Digest::MD5.hexdigest(
+          "#{Digest::MD5.hexdigest("#{username}:#{REALM}:#{password}")}:#{nonce}:#{nc}:#{cnonce}:auth-int:#{Digest::MD5.hexdigest('POST:/:' + Digest::MD5.hexdigest('body'))}"
+        )
+
+        @request.method = 'POST'
+        @request.update_header('Authorization', "Digest username=\"#{username}\", realm=\"#{REALM}\", nonce=\"#{nonce}\", uri=\"/\", response=\"#{digest_hash}\", opaque=\"#{opaque}\", qop=auth-int,nc=#{nc},cnonce=\"#{cnonce}\"")
+        @request.body = 'body'
+
+        @auth.init
+
+        assert(@auth.validate_a1(Digest::MD5.hexdigest("#{username}:#{REALM}:#{password}")), 'Authentication is deemed invalid through validateA1')
+      end
+    end
+  end
+end

data/test/http/client_mock.rb

@@ -0,0 +1,101 @@
+# TODO: document
+module Tilia
+  module Http
+    class ClientMock < Client
+      # RUBY: attr_accessor :persisted_settings
+
+      # Making this method public.
+      #
+      # We are also going to persist all settings this method generates. While
+      # the underlying object doesn't behave exactly the same, it helps us
+      # simulate what curl does internally, and helps us identify problems with
+      # settings that are set by _some_ methods and not correctly reset by other
+      # methods after subsequent use.
+      # forces
+      def create_curl_settings_array(request)
+        settings = super(request)
+        settings = @persisted_settings.merge(settings)
+        @persisted_settings = settings
+        settings
+      end
+
+      # Making this method public.
+      def parse_curl_result(curl_handle)
+        super(curl_handle)
+      end
+
+      # This method is responsible for performing a single request.
+      #
+      # @param RequestInterface request
+      # @return [ResponseInterface]
+      def do_request(request)
+        response = nil
+
+        do_request_arguments = DoRequestArguments.new(request, response)
+        emit('doRequest', [do_request_arguments])
+        (request, response) = do_request_arguments.to_a
+
+        # If nothing modified response, we're using the default behavior.
+        if response.nil?
+          super(request)
+        else
+          response
+        end
+      end
+
+      protected
+
+      # Returns a bunch of information about a curl request.
+      #
+      # This method exists so it can easily be overridden and mocked.
+      #
+      # @param resource curl_handle
+      # @return array
+      def curl_stuff(curl_handle)
+        to_return = nil
+        curl_stuff_arguments = CurlStuffArguments.new(to_return)
+        emit('curlStuff', [curl_stuff_arguments])
+        (to_return,) = curl_stuff_arguments.to_a
+
+        # If nothing modified return, we're using the default behavior.
+        if to_return.nil?
+          super(curl_handle)
+        else
+          to_return
+        end
+      end
+
+      # Calls curl_exec
+      #
+      # This method exists so it can easily be overridden and mocked.
+      #
+      # @param resource curl_handle
+      # @return [String]
+      def curl_exec(curl_handle, request)
+        to_return = nil
+        curl_exec_arguments = CurlExecArguments.new(to_return)
+        emit('curlExec', [curl_exec_arguments])
+        (to_return,) = curl_exec_arguments.to_a
+
+        # If nothing modified return, we're using the default behavior.
+        if to_return.nil?
+          super(curl_handle, request)
+        else
+          to_return
+        end
+      end
+
+      public
+
+      # TODO: document
+      def initialize
+        @persisted_settings = {}
+        super
+      end
+
+      DoRequestArguments = Struct.new(:request, :response)
+      CurlStuffArguments = Struct.new(:return)
+      CurlExecArguments = Struct.new(:curl_handle)
+    end
+  end
+end

data/test/http/client_test.rb

@@ -0,0 +1,331 @@
+require 'test_helper'
+require 'stringio'
+require 'http/client_mock'
+
+module Tilia
+  module Http
+    class ClientTest < Minitest::Test
+      # it 'testCreateCurlSettingsArrayGET' do
+      #   client = ClientMock.new
+      #   client.add_curl_setting(Curl::CURLOPT_POSTREDIR, 0)
+      #
+      #   request = Request.new('GET', 'http://example.org/', { 'X-Foo' => 'bar' })
+      #
+      #   settings = {
+      #     Curl::CURLOPT_HEADER         => true,
+      #     Curl::CURLOPT_POSTREDIR      => 0,
+      #     :CURLOPT_HTTPHEADER     => ['X-Foo: bar'],
+      #     Curl::CURLOPT_NOBODY         => false,
+      #     Curl::CURLOPT_URL            => 'http://example.org/',
+      #     Curl::CURLOPT_CUSTOMREQUEST  => 'GET',
+      #     Curl::CURLOPT_POSTFIELDS     => '',
+      #     :CURLOPT_PUT            => false
+      #   }
+      #
+      #   assert_equal(settings, client.create_curl_settings_array(request))
+      # end
+      #
+      # it 'testCreateCurlSettingsArrayHEAD' do
+      #   client = ClientMock.new
+      #   request = Request.new('HEAD', 'http://example.org/', {'X-Foo' => 'bar'})
+      #
+      #   settings = {
+      #     Curl::CURLOPT_HEADER         => true,
+      #     Curl::CURLOPT_NOBODY         => true,
+      #     Curl::CURLOPT_CUSTOMREQUEST  => 'HEAD',
+      #     :CURLOPT_HTTPHEADER     => ['X-Foo: bar'],
+      #     Curl::CURLOPT_URL            => 'http://example.org/',
+      #     Curl::CURLOPT_POSTFIELDS     => '',
+      #     :CURLOPT_PUT            => false
+      #   }
+      #
+      #   assert_equal(settings, client.create_curl_settings_array(request))
+      # end
+      #
+      # it 'testCreateCurlSettingsArrayGETAfterHEAD' do
+      #   client = ClientMock.new
+      #   request = Request.new('HEAD', 'http://example.org/', {'X-Foo' => 'bar'})
+      #
+      #   # Parsing the settings for this method, and discarding the result.
+      #   # This will cause the client to automatically persist previous
+      #   # settings and will help us detect problems.
+      #   client.create_curl_settings_array(request)
+      #
+      #   # This is the real request.
+      #   request = Request.new('GET', 'http://example.org/', {'X-Foo' => 'bar'})
+      #
+      #   settings = {
+      #     Curl::CURLOPT_CUSTOMREQUEST  => 'GET',
+      #     Curl::CURLOPT_HEADER         => true,
+      #     :CURLOPT_HTTPHEADER     => ['X-Foo: bar'],
+      #     Curl::CURLOPT_NOBODY         => false,
+      #     Curl::CURLOPT_URL            => 'http://example.org/',
+      #     Curl::CURLOPT_POSTFIELDS     => '',
+      #     :CURLOPT_PUT            => false
+      #   }
+      #
+      #   assert_equal(settings, client.create_curl_settings_array(request))
+      # end
+      #
+      # it 'testCreateCurlSettingsArrayPUTStream' do
+      #   pending
+      #   client = ClientMock.new
+      #
+      #   h = StringIO.new
+      #   h.write('booh')
+      #   request = Request.new('PUT', 'http://example.org/', {'X-Foo' => 'bar'}, h)
+      #
+      #   settings = {
+      #     Curl::CURLOPT_HEADER         => true,
+      #     :CURLOPT_PUT            => true,
+      #     :CURLOPT_INFILE         => h,
+      #     Curl::CURLOPT_NOBODY         => false,
+      #     Curl::CURLOPT_CUSTOMREQUEST  => 'PUT',
+      #     :CURLOPT_HTTPHEADER     => ['X-Foo: bar'],
+      #     Curl::CURLOPT_URL            => 'http://example.org/'
+      #   }
+      #
+      #   assert_equal(settings, client.create_curl_settings_array(request))
+      # end
+      #
+      # it 'testCreateCurlSettingsArrayPUTString' do
+      #   client = ClientMock.new
+      #   request = Request.new('PUT', 'http://example.org/', {'X-Foo' => 'bar'}, 'boo')
+      #
+      #   settings = {
+      #     Curl::CURLOPT_HEADER         => true,
+      #     Curl::CURLOPT_NOBODY         => false,
+      #     Curl::CURLOPT_POSTFIELDS     => 'boo',
+      #     Curl::CURLOPT_CUSTOMREQUEST  => 'PUT',
+      #     :CURLOPT_HTTPHEADER     => ['X-Foo: bar'],
+      #     Curl::CURLOPT_URL            => 'http://example.org/'
+      #   }
+      #
+      #   assert_equal(settings, client.create_curl_settings_array(request))
+      # end
+
+      def test_send
+        client = ClientMock.new
+        request = Request.new('GET', 'http://example.org/')
+
+        response = nil
+        client.on(
+          'doRequest',
+          lambda do |_|
+            response = Response.new(200)
+          end
+        )
+
+        response = client.send(request)
+
+        assert_equal(200, response.status)
+      end
+
+      def test_send_client_error
+        client = ClientMock.new
+        request = Request.new('GET', 'http://example.org/')
+
+        client.on(
+          'doRequest',
+          lambda do |_|
+            fail ClientException, 'aaah'
+          end
+        )
+
+        called = false
+        client.on(
+          'exception',
+          lambda do |_a, _b, _c, _d|
+            called = true
+          end
+        )
+
+        assert_raises(ClientException) { client.send(request) }
+
+        assert(called)
+      end
+
+      def test_send_http_error
+        client = ClientMock.new
+        request = Request.new('GET', 'http://example.org/')
+
+        client.on(
+          'doRequest',
+          lambda do |args|
+            args.response = Response.new(404)
+          end
+        )
+
+        called = 0
+        client.on(
+          'error',
+          lambda do |_a, _b, _c, _d|
+            called += 1
+          end
+        )
+        client.on(
+          'error:404',
+          lambda do |_a, _b, _c, _d|
+            called += 1
+          end
+        )
+
+        client.send(request)
+        assert_equal(2, called)
+      end
+
+      def test_send_retry
+        client = ClientMock.new
+        request = Request.new('GET', 'http://example.org/')
+
+        called = 0
+        client.on(
+          'doRequest',
+          lambda do |args|
+            called += 1
+            if called < 3
+              args.response = Response.new(404)
+            else
+              args.response = Response.new(200)
+            end
+          end
+        )
+
+        error_called = 0
+        client.on(
+          'error',
+          lambda do |_a, _b, do_retry, _d|
+            error_called += 1
+            do_retry.value = true
+          end
+        )
+
+        response = client.send(request)
+        assert_equal(3, called)
+        assert_equal(2, error_called)
+        assert_equal(200, response.status)
+      end
+
+      def test_http_error_exception
+        client = ClientMock.new
+        client.throw_exceptions = true
+        request = Request.new('GET', 'http://example.org/')
+
+        client.on(
+          'doRequest',
+          lambda do |args|
+            args.response = Response.new(404)
+          end
+        )
+
+        error = assert_raises(Exception) { client.send(request) }
+        assert_kind_of(ClientHttpException, error)
+        assert_equal(404, error.http_status)
+        assert_kind_of(Response, error.response)
+      end
+
+      # it 'testParseCurlResult' do
+      #   client = ClientMock.new
+      #   client.on(
+      #     'curlStuff',
+      #     lambda do |args|
+      #       args.return = [
+      #         {
+      #           'header_size' => 33,
+      #           'http_code'   => 200
+      #         },
+      #         0,
+      #         ''
+      #       ]
+      #     end
+      #   )
+      #
+      #   body = "HTTP/1.1 200 OK\r\nHeader1:Val1\r\n\r\nFoo"
+      #   result = client.parse_curl_result(body, 'foobar')
+      #
+      #   assert_equal(Client::STATUS_SUCCESS, result['status'])
+      #   assert_equal(200, result['http_code'])
+      #   assert_equal(200, result['response'].status)
+      #   assert_equal({ 'Header1' => ['Val1'] }, result['response'].headers)
+      #   assert_equal('Foo', result['response'].body_as_string)
+      # end
+      #
+      # it 'testParseCurlError' do
+      #   client = ClientMock.new
+      #   client.on(
+      #     'curlStuff',
+      #     lambda do |args|
+      #       args.return = [
+      #         { },
+      #         1,
+      #         'Curl error'
+      #       ]
+      #     end
+      #   )
+      #
+      #   body = "HTTP/1.1 200 OK\r\nHeader1:Val1\r\n\r\nFoo"
+      #   result = client.parse_curl_result(body, 'foobar')
+      #
+      #   assert_equal(Client::STATUS_CURLERROR, result['status'])
+      #   assert_equal(1, result['curl_errno'])
+      #   assert_equal('Curl error', result['curl_errmsg'])
+      # end
+      #
+      # it 'testDoRequest' do
+      #   client = ClientMock.new
+      #   request = Request.new('GET', 'http://example.org/')
+      #   client.on(
+      #     'curlExec',
+      #     lambda do |args|
+      #       args.curl_handle = "HTTP/1.1 200 OK\r\nHeader1:Val1\r\n\r\nFoo"
+      #     end
+      #   )
+      #
+      #   client.on(
+      #     'curlStuff',
+      #     lambda do |args|
+      #       args.return = [
+      #         {
+      #           'header_size' => 33,
+      #             'http_code'   => 200
+      #         },
+      #         0,
+      #         ''
+      #       ]
+      #     end
+      #   )
+      #   response = client.do_request(request)
+      #   assert_equal(200, response.status)
+      #   assert_equal({ 'Header1' => ['Val1'] }, response.headers)
+      #   assert_equal('Foo', response.body_as_string)
+      # end
+      #
+      # it 'testDoRequestCurlError' do
+      #   client = ClientMock.new
+      #   request = Request.new('GET', 'http://example.org/')
+      #   client.on(
+      #     'curlExec',
+      #     lambda do |args|
+      #       args.curl_handle = ''
+      #     end
+      #   )
+      #
+      #   client.on(
+      #     'curlStuff',
+      #     lambda do |args|
+      #       args.return = [
+      #         { },
+      #         1,
+      #         'Curl error'
+      #       ]
+      #     end
+      #   )
+      #
+      #   expect { response = client.do_request(request) }.to raise_error ClientException do |error|
+      #     assert_equal(1, error.code)
+      #     assert_equal('Curl error', error.message)
+      #   end
+      # end
+    end
+  end
+end

data/test/http/message_decorator_test.rb

@@ -0,0 +1,67 @@
+require 'test_helper'
+
+module Tilia
+  module Http
+    class MessageDecoratorTest < Minitest::Test
+      def setup
+        @inner = Tilia::Http::Request.new
+        @outer = Tilia::Http::RequestDecorator.new(@inner)
+      end
+
+      def test_body
+        @outer.body = 'foo'
+        assert_equal('foo', @inner.body_as_stream.readlines.join(''))
+        assert_equal('foo', @outer.body_as_stream.readlines.join(''))
+        assert_equal('foo', @inner.body_as_string)
+        assert_equal('foo', @outer.body_as_string)
+        assert_equal('foo', @inner.body)
+        assert_equal('foo', @outer.body)
+      end
+
+      def test_headers
+        @outer.update_headers('a' => 'b')
+
+        assert_equal({ 'a' => ['b'] }, @inner.headers)
+        assert_equal({ 'a' => ['b'] }, @outer.headers)
+
+        @outer.update_headers('c' => 'd')
+
+        assert_equal({ 'a' => ['b'], 'c' => ['d'] }, @inner.headers)
+        assert_equal({ 'a' => ['b'], 'c' => ['d'] }, @outer.headers)
+
+        @outer.add_headers('e' => 'f')
+
+        assert_equal({ 'a' => ['b'], 'c' => ['d'], 'e' => ['f'] }, @inner.headers)
+        assert_equal({ 'a' => ['b'], 'c' => ['d'], 'e' => ['f'] }, @outer.headers)
+      end
+
+      def test_header
+        refute(@outer.header?('a'))
+        refute(@inner.header?('a'))
+        @outer.update_header('a', 'c')
+        assert(@outer.header?('a'))
+        assert(@inner.header?('a'))
+
+        assert_equal('c', @inner.header('A'))
+        assert_equal('c', @outer.header('A'))
+
+        @outer.add_header('A', 'd')
+
+        assert_equal(['c', 'd'], @inner.header_as_array('A'))
+        assert_equal(['c', 'd'], @outer.header_as_array('A'))
+
+        @outer.remove_header('a')
+
+        assert_nil(@inner.header('A'))
+        assert_nil(@outer.header('A'))
+      end
+
+      def test_http_version
+        @outer.http_version = '1.0'
+
+        assert_equal('1.0', @inner.http_version)
+        assert_equal('1.0', @outer.http_version)
+      end
+    end
+  end
+end