tilia-http 4.1.0

data/test/http/message_test.rb

@@ -0,0 +1,163 @@
+require 'test_helper'
+require 'stringio'
+
+module Tilia
+  module Http
+    class MessageTest < Minitest::Test
+      def test_construct
+        message = MessageMock.new
+        assert_kind_of(Message, message)
+      end
+
+      def test_stream_body
+        body = 'foo'
+        h = StringIO.new
+        h.write(body)
+        h.rewind
+
+        message = MessageMock.new
+        message.body = h
+
+        assert_equal(body, message.body_as_string)
+        h.rewind
+        assert_equal(body, message.body_as_stream.readlines.join(''))
+        h.rewind
+        assert_equal(body, message.body.readlines.join(''))
+      end
+
+      def test_string_body
+        body = 'foo'
+
+        message = MessageMock.new
+        message.body = body
+
+        assert_equal(body, message.body_as_string)
+        assert_equal(body, message.body_as_stream.readlines.join(''))
+        assert_equal(body, message.body)
+      end
+
+      def test_get_empty_body_stream
+        message = MessageMock.new
+        body = message.body_as_stream
+
+        assert_equal('', body.readlines.join(''))
+      end
+
+      def test_get_empty_body_string
+        message = MessageMock.new
+        body = message.body_as_string
+
+        assert_equal('', body)
+      end
+
+      def test_headers
+        message = MessageMock.new
+        message.update_header('X-Foo', 'bar')
+
+        # Testing caselessness
+        assert_equal('bar', message.header('X-Foo'))
+        assert_equal('bar', message.header('x-fOO'))
+
+        assert(message.remove_header('X-FOO'))
+        assert_nil(message.header('X-Foo'))
+        refute(message.remove_header('X-FOO'))
+      end
+
+      def test_set_headers
+        message = MessageMock.new
+
+        headers = {
+          'X-Foo' => ['1'],
+          'X-Bar' => ['2']
+        }
+
+        message.update_headers(headers)
+        assert_equal(headers, message.headers)
+
+        message.update_headers(
+          'X-Foo' => ['3', '4'],
+          'X-Bar' => '5'
+        )
+
+        expected = {
+          'X-Foo' => ['3', '4'],
+          'X-Bar' => ['5']
+        }
+
+        assert_equal(expected, message.headers)
+      end
+
+      def test_add_headers
+        message = MessageMock.new
+
+        headers = {
+          'X-Foo' => ['1'],
+          'X-Bar' => ['2']
+        }
+
+        message.add_headers(headers)
+        assert_equal(headers, message.headers)
+
+        message.add_headers(
+          'X-Foo' => ['3', '4'],
+          'X-Bar' => '5'
+        )
+
+        expected = {
+          'X-Foo' => ['1', '3', '4'],
+          'X-Bar' => ['2', '5']
+        }
+
+        assert_equal(expected, message.headers)
+      end
+
+      def test_send_body
+        message = MessageMock.new
+
+        # String
+        message.body = 'foo'
+
+        # Stream
+        h = StringIO.new
+        h.write('bar')
+        h.rewind
+        message.body = h
+
+        body = message.body
+        body.rewind
+
+        assert_equal('bar', body.readlines.join(''))
+      end
+
+      def test_multiple_headers
+        message = MessageMock.new
+        message.update_header('a', '1')
+        message.add_header('A', '2')
+
+        assert_equal('1,2', message.header('A'))
+        assert_equal('1,2', message.header('a'))
+
+        assert_equal(['1', '2'], message.header_as_array('A'))
+        assert_equal(['1', '2'], message.header_as_array('a'))
+
+        assert_equal([], message.header_as_array('B'))
+      end
+
+      def test_has_headers
+        message = MessageMock.new
+
+        refute(message.header?('X-Foo'))
+        message.update_header('X-Foo', 'Bar')
+        assert(message.header?('X-Foo'))
+      end
+    end
+
+    class MessageMock
+      include Message
+
+      def initialize
+        initialize_message
+      end
+    end
+  end
+end

data/test/http/request_decorator_test.rb

@@ -0,0 +1,87 @@
+require 'test_helper'
+
+module Tilia
+  module Http
+    class RequestDecoratorTest < Minitest::Test
+      def setup
+        @inner = Request.new
+        @outer = RequestDecorator.new(@inner)
+      end
+
+      def test_method
+        @outer.method = 'FOO'
+        assert_equal('FOO', @inner.method)
+        assert_equal('FOO', @outer.method)
+      end
+
+      def test_url
+        @outer.url = '/foo'
+        assert_equal('/foo', @inner.url)
+        assert_equal('/foo', @outer.url)
+      end
+
+      def test_absolute_url
+        @outer.absolute_url = 'http://example.org/foo'
+        assert_equal('http://example.org/foo', @inner.absolute_url)
+        assert_equal('http://example.org/foo', @outer.absolute_url)
+      end
+
+      def test_base_url
+        @outer.base_url = '/foo'
+        assert_equal('/foo', @inner.base_url)
+        assert_equal('/foo', @outer.base_url)
+      end
+
+      def test_path
+        @outer.base_url = '/foo'
+        @outer.url = '/foo/bar'
+        assert_equal('bar', @inner.path)
+        assert_equal('bar', @outer.path)
+      end
+
+      def test_query_params
+        @outer.url = '/foo?a=b&c=d&e'
+        expected = {
+          'a' => 'b',
+          'c' => 'd',
+          'e' => nil
+        }
+
+        assert_equal(expected, @inner.query_parameters)
+        assert_equal(expected, @outer.query_parameters)
+      end
+
+      def test_post_data
+        post_data = {
+          'a' => 'b',
+          'c' => 'd',
+          'e' => nil
+        }
+
+        @outer.post_data = post_data
+        assert_equal(post_data, @outer.post_data)
+        assert_equal(post_data, @inner.post_data)
+      end
+
+      def test_server_data
+        server_data = { 'HTTPS' => 'On' }
+
+        @outer.raw_server_data = server_data
+        assert_equal('On', @inner.raw_server_value('HTTPS'))
+        assert_equal('On', @outer.raw_server_value('HTTPS'))
+
+        assert_nil(@inner.raw_server_value('FOO'))
+        assert_nil(@outer.raw_server_value('FOO'))
+      end
+
+      def test_to_string
+        @inner.method = 'POST'
+        @inner.url = '/foo/bar/'
+        @inner.body = 'foo'
+        @inner.update_header('foo', 'bar')
+
+        assert_equal(@inner.to_s, @outer.to_s)
+      end
+    end
+  end
+end

data/test/http/request_test.rb

@@ -0,0 +1,132 @@
+require 'test_helper'
+require 'http/sapi_mock'
+
+module Tilia
+  module Http
+    class RequestTest < Minitest::Test
+      def test_construct
+        request = Request.new('GET', '/foo', 'User-Agent' => 'Evert')
+        assert_equal('GET', request.method)
+        assert_equal('/foo', request.url)
+        assert_equal({ 'User-Agent' => ['Evert'] }, request.headers)
+      end
+
+      def test_get_query_parameters
+        request = Request.new('GET', '/foo?a=b&c&d=e')
+        assert_equal(
+          {
+            'a' => 'b',
+            'c' => nil,
+            'd' => 'e'
+          },
+          request.query_parameters
+        )
+      end
+
+      def test_get_query_parameters_no_data
+        request = Request.new('GET', '/foo')
+        assert_equal({}, request.query_parameters)
+      end
+
+      def test_create_from_php_request
+        sapi = SapiMock.new('REQUEST_METHOD' => 'PUT')
+
+        request = sapi.request
+        assert_equal('PUT', request.method)
+      end
+
+      def test_get_absolute_url
+        s = {
+          'HTTP_HOST'   => 'sabredav.org',
+          'REQUEST_URI' => '/foo'
+        }
+
+        r = Sapi.create_from_server_array(s)
+
+        assert_equal('http://sabredav.org/foo', r.absolute_url)
+
+        s = {
+          'HTTP_HOST'   => 'sabredav.org',
+          'REQUEST_URI' => '/foo',
+          'HTTPS'       => 'on'
+        }
+
+        r = Sapi.create_from_server_array(s)
+
+        assert_equal('https://sabredav.org/foo', r.absolute_url)
+      end
+
+      def test_get_post_data
+        post = { 'bla' => 'foo' }
+        r = Request.new
+        r.post_data = post
+        assert_equal(post, r.post_data)
+      end
+
+      def test_get_path
+        request = Request.new
+        request.base_url = '/foo'
+        request.url = '/foo/bar/'
+
+        assert_equal('bar', request.path)
+      end
+
+      def test_get_path_stripped_query
+        request = Request.new
+        request.base_url = '/foo'
+        request.url = '/foo/bar/?a=b'
+
+        assert_equal('bar', request.path)
+      end
+
+      def test_get_path_missing_slash
+        request = Request.new
+        request.base_url = '/foo/'
+        request.url = '/foo'
+
+        assert_equal('', request.path)
+      end
+
+      def test_get_path_outside_base_url
+        request = Request.new
+        request.base_url = '/foo/'
+        request.url = '/bar/'
+
+        assert_raises(RuntimeError) { request.path }
+      end
+
+      def test_to_string
+        request = Request.new('PUT', '/foo/bar', 'Content-Type' => 'text/xml')
+        request.body = 'foo'
+
+        expected = <<HI
+PUT /foo/bar HTTP/1.1\r
+Content-Type: text/xml\r
+\r
+foo
+HI
+        expected.chomp!
+        assert_equal(expected, request.to_s)
+      end
+
+      def test_to_string_authorization
+        request = Request.new('PUT', '/foo/bar', 'Content-Type' => 'text/xml', 'Authorization' => 'Basic foobar')
+        request.body = 'foo'
+
+        expected = <<HI
+PUT /foo/bar HTTP/1.1\r
+Content-Type: text/xml\r
+Authorization: Basic REDACTED\r
+\r
+foo
+HI
+        expected.chomp!
+        assert_equal(expected, request.to_s)
+      end
+
+      def test_constructor_with_array
+        assert_raises(ArgumentError) { Request.new([]) }
+      end
+    end
+  end
+end

data/test/http/response_decorator_test.rb

@@ -0,0 +1,28 @@
+require 'test_helper'
+
+module Tilia
+  module Http
+    class ResponseDecoratorTest < Minitest::Test
+      def setup
+        @inner = Response.new
+        @outer = ResponseDecorator.new(@inner)
+      end
+
+      def test_status
+        @outer.status = 201
+        assert_equal(201, @inner.status)
+        assert_equal(201, @outer.status)
+        assert_equal('Created', @inner.status_text)
+        assert_equal('Created', @outer.status_text)
+      end
+
+      def test_to_string
+        @inner.status = 201
+        @inner.body = 'foo'
+        @inner.update_header('foo', 'bar')
+
+        assert_equal(@inner.to_s, @outer.to_s)
+      end
+    end
+  end
+end

data/test/http/response_test.rb

@@ -0,0 +1,38 @@
+require 'test_helper'
+
+module Tilia
+  module Http
+    class ResponseTest < Minitest::Test
+      def test_construct
+        response = Response.new(200, 'Content-Type' => 'text/xml')
+        assert_equal(200, response.status)
+        assert_equal('OK', response.status_text)
+      end
+
+      def test_set_status
+        response = Response.new
+        response.status = '402 Where\'s my money?'
+        assert_equal(402, response.status)
+        assert_equal('Where\'s my money?', response.status_text)
+      end
+
+      def test_invalid_status
+        assert_raises(ArgumentError) { Response.new(1000) }
+      end
+
+      def test_to_string
+        response = Response.new(200, 'Content-Type' => 'text/xml')
+        response.body = 'foo'
+
+        expected = <<HI
+HTTP/1.1 200 OK\r
+Content-Type: text/xml\r
+\r
+foo
+HI
+        expected.chomp!
+        assert_equal(expected, response.to_s)
+      end
+    end
+  end
+end

data/test/http/sapi_mock.rb

@@ -0,0 +1,12 @@
+module Tilia
+  module Http
+    # TODO: document
+    class SapiMock < Sapi
+      # TODO: document
+      def initialize(env = {})
+        env = Rack::MockRequest.env_for.merge env
+        super(env)
+      end
+    end
+  end
+end

data/test/http/sapi_test.rb

@@ -0,0 +1,133 @@
+require 'test_helper'
+require 'base64'
+require 'stringio'
+require 'http/sapi_mock'
+
+module Tilia
+  module Http
+    class SapiTest < Minitest::Test
+      def test_construct_from_server_array
+        request = Sapi.create_from_server_array(
+          'REQUEST_URI'     => '/foo',
+          'REQUEST_METHOD'  => 'GET',
+          'HTTP_USER_AGENT' => 'Evert',
+          'CONTENT_TYPE'    => 'text/xml',
+          'CONTENT_LENGTH'  => '400',
+          'SERVER_PROTOCOL' => 'HTTP/1.0'
+        )
+
+        assert_equal('GET', request.method)
+        assert_equal('/foo', request.url)
+        assert_equal(
+          {
+            'User-Agent'     => ['Evert'],
+            'Content-Type'   => ['text/xml'],
+            'Content-Length' => ['400']
+          },
+          request.headers
+        )
+
+        assert_equal('1.0', request.http_version)
+
+        assert_equal('400', request.raw_server_value('CONTENT_LENGTH'))
+        assert_nil(request.raw_server_value('FOO'))
+      end
+
+      def test_construct_php_auth
+        request = Sapi.create_from_server_array(
+          'REQUEST_URI'     => '/foo',
+          'REQUEST_METHOD'  => 'GET',
+          'PHP_AUTH_USER'   => 'user',
+          'PHP_AUTH_PW'     => 'pass'
+        )
+
+        assert_equal('GET', request.method)
+        assert_equal('/foo', request.url)
+        assert_equal(
+          {
+            'Authorization' => ["Basic #{Base64.strict_encode64('user:pass')}"]
+          },
+          request.headers
+        )
+      end
+
+      def test_construct_php_auth_digest
+        request = Sapi.create_from_server_array(
+          'REQUEST_URI'     => '/foo',
+          'REQUEST_METHOD'  => 'GET',
+          'PHP_AUTH_DIGEST' => 'blabla'
+        )
+
+        assert_equal('GET', request.method)
+        assert_equal('/foo', request.url)
+        assert_equal(
+          {
+            'Authorization' => ['Digest blabla']
+          },
+          request.headers
+        )
+      end
+
+      def test_construct_redirect_auth
+        request = Sapi.create_from_server_array(
+          'REQUEST_URI'                 => '/foo',
+          'REQUEST_METHOD'              => 'GET',
+          'REDIRECT_HTTP_AUTHORIZATION' => 'Basic bla'
+        )
+
+        assert_equal('GET', request.method)
+        assert_equal('/foo', request.url)
+        assert_equal(
+          {
+            'Authorization' => ['Basic bla']
+          },
+          request.headers
+        )
+      end
+
+      def test_send
+        response = Response.new(204, 'Content-Type' => 'text/xml;charset=UTF-8')
+
+        # Second Content-Type header. Normally this doesn't make sense.
+        response.add_header('Content-Type', 'application/xml')
+        response.body = 'foo'
+
+        (_status, headers, body) = Sapi.send_response(response)
+
+        assert_equal(
+          {
+            'Content-Type' => "text/xml;charset=UTF-8\napplication/xml"
+          },
+          headers
+        )
+
+        assert_equal('foo', body.readlines.join(''))
+      end
+
+      def test_send_limited_by_content_length_string
+        response = Response.new(200)
+
+        response.add_header('Content-Length', 19)
+        response.body = 'Send this sentence. Ignore this one.'
+
+        (_status, _headers, body) = Sapi.send_response(response)
+
+        assert_equal('Send this sentence.', body.readlines.join(''))
+      end
+
+      def test_send_limited_by_content_length_stream
+        response = Response.new(200, 'Content-Length' => 19)
+
+        body = StringIO.new
+        body.write('Ignore this. Send this sentence. Ignore this too.')
+        body.rewind
+        body.read(13)
+        response.body = body
+
+        (_status, _headers, body) = Sapi.send_response(response)
+
+        assert_equal('Send this sentence.', body.readlines.join(''))
+      end
+    end
+  end
+end