webbed 0.1.1 → 0.2.0

data/test/webbed/http_version_test.rb

@@ -0,0 +1,52 @@
+require 'test_helper'
+
+module WebbedTest
+  class HTTPVersionTest < TestCase
+    test '#initialize with string' do
+      version = Webbed::HTTPVersion.new('HTTP/1.1')
+      assert_equal 1, version.major
+      assert_equal 1, version.minor
+    end
+    
+    test '#initialize with float' do
+      version = Webbed::HTTPVersion.new(2.0)
+      assert_equal 2, version.major
+      assert_equal 0, version.minor
+    end
+    
+    test '#to_s' do
+      assert_equal 'HTTP/2.0', Webbed::HTTPVersion.new('HTTP/2.0').to_s
+      assert_equal 'HTTP/2.0', Webbed::HTTPVersion.new(2.0).to_s
+    end
+    
+    test '#to_f' do
+      version = Webbed::HTTPVersion.new('HTTP/2.0')
+      assert_equal 2.0, version.to_f
+      
+      version = Webbed::HTTPVersion.new(2.0)
+      assert_equal 2.0, version.to_f
+    end
+    
+    test 'comparisons' do
+      one_point_one = Webbed::HTTPVersion.new('HTTP/1.1')
+      two_point_oh1 = Webbed::HTTPVersion.new('HTTP/2.0')
+      two_point_oh2 = Webbed::HTTPVersion.new('HTTP/2.0')
+      
+      assert_equal 1.1, one_point_one
+      refute_equal 1.0, one_point_one
+      assert_equal two_point_oh1, two_point_oh2
+      
+      assert_comparable one_point_one, two_point_oh1
+    end
+    
+    test 'ONE_POINT_ONE' do
+      assert_equal 1, Webbed::HTTPVersion::ONE_POINT_ONE.major
+      assert_equal 1, Webbed::HTTPVersion::ONE_POINT_ONE.minor
+    end
+    
+    test 'ONE_POINT_OH' do
+      assert_equal 1, Webbed::HTTPVersion::ONE_POINT_OH.major
+      assert_equal 0, Webbed::HTTPVersion::ONE_POINT_OH.minor
+    end
+  end
+end

data/test/webbed/media_type_test.rb

@@ -0,0 +1,100 @@
+require 'test_helper'
+
+module WebbedTest
+  class MediaTypeTest < TestCase
+    test '#initialize with only MIME type' do
+      media_type = Webbed::MediaType.new('text/html')
+      
+      assert_equal 'text', media_type.type
+      assert_equal 'html', media_type.subtype
+      assert_equal 'text/html', media_type.mime_type
+      assert media_type.parameters.empty?
+    end
+    
+    test '#initialize with MIME type and parameters' do
+      media_type = Webbed::MediaType.new('text/html; foo=bar; lol=rofl')
+      
+      assert_equal 'text', media_type.type
+      assert_equal 'html', media_type.subtype
+      assert_equal 'text/html', media_type.mime_type
+      assert_equal 'bar', media_type.parameters['foo']
+      assert_equal 'rofl', media_type.parameters['lol']
+    end
+    
+    test '#initialize with MIME type and weirdly spaced parameters' do
+      media_type = Webbed::MediaType.new('text/html;   foo=bar ; lol=rofl')
+      
+      assert_equal 'text', media_type.type
+      assert_equal 'html', media_type.subtype
+      assert_equal 'text/html', media_type.mime_type
+      assert_equal 'bar', media_type.parameters['foo']
+      assert_equal 'rofl', media_type.parameters['lol']
+    end
+    
+    test '#mime_type' do
+      media_type = Webbed::MediaType.new('text/html; foo=bar; lol=rofl')
+      media_type.mime_type = 'application/json'
+      
+      assert_equal 'application', media_type.type
+      assert_equal 'json', media_type.subtype
+      assert_equal 'application/json', media_type.mime_type
+    end
+    
+    test '#type' do
+      media_type = Webbed::MediaType.new('text/html; foo=bar; lol=rofl')
+      media_type.type = 'image'
+      
+      assert_equal 'image', media_type.type
+      assert_equal 'html', media_type.subtype
+      assert_equal 'image/html', media_type.mime_type
+    end
+    
+    test '#subtype' do
+      media_type = Webbed::MediaType.new('text/html; foo=bar; lol=rofl')
+      media_type.subtype = 'xml'
+      
+      assert_equal 'text', media_type.type
+      assert_equal 'xml', media_type.subtype
+      assert_equal 'text/xml', media_type.mime_type
+    end
+    
+    test '#parameters' do
+      media_type = Webbed::MediaType.new('text/html; foo=bar; lol=rofl')
+      media_type.parameters = { 'test' => 'lol' }
+      
+      assert_equal 'lol', media_type.parameters['test']
+    end
+    
+    test '#to_s' do
+      assert_equal 'text/html', Webbed::MediaType.new('text/html').to_s
+      
+      media_type_string = Webbed::MediaType.new('text/html; foo=bar; lol=rofl').to_s
+      assert media_type_string.include?('; lol=rofl')
+      assert media_type_string.include?('; foo=bar')
+      assert media_type_string.include?('text/html')
+    end
+    
+    test '#vendor_specific?' do
+      refute Webbed::MediaType.new('text/html; foo=bar; lol=rofl').vendor_specific?
+      assert Webbed::MediaType.new('application/vnd.lol+xml').vendor_specific?
+    end
+    
+    test '#suffix' do
+      suffixed = Webbed::MediaType.new('application/atom+xml')
+      assert_equal 'xml', suffixed.suffix
+      assert_includes suffixed.interpretable_as, 'application/xml'
+      assert_includes suffixed.interpretable_as, 'application/atom+xml'
+      
+      not_suffixed = Webbed::MediaType.new('text/html')
+      assert_nil not_suffixed.suffix
+      assert_includes not_suffixed.interpretable_as, 'text/html'
+    end
+    
+    test 'equality' do
+      json = Webbed::MediaType.new('application/json')
+      
+      assert_equal Webbed::MediaType.new('application/json'), json
+      refute_equal Webbed::MediaType.new('text/html'), json
+    end
+  end
+end

data/test/webbed/method_test.rb

@@ -0,0 +1,160 @@
+require 'test_helper'
+
+module WebbedTest
+  class MethodTest < TestCase
+    test '#initialize without options' do
+      fake = Webbed::Method.new('FAKE')
+      
+      assert_equal 'FAKE', fake.to_s
+      refute fake.safe?
+      refute fake.idempotent?
+      assert_includes fake.allowable_entities, :request
+      assert_includes fake.allowable_entities, :response
+    end
+    
+    test '#initialize a safe Method' do
+      fake = Webbed::Method.new('FAKE', :safe => true)
+      assert fake.safe?
+      assert fake.idempotent?
+    end
+    
+    test '#initialize an idempotent Method' do
+      fake = Webbed::Method.new('FAKE', :idempotent => true)
+      refute fake.safe?
+      assert fake.idempotent?
+    end
+    
+    test '#initialize an unsafe Method' do
+      fake = Webbed::Method.new('FAKE', :safe => false)
+      refute fake.safe?
+      refute fake.idempotent?
+    end
+    
+    test '#initialize a headers-only Method' do
+      fake = Webbed::Method.new('FAKE', :allowable_entities => [])
+      refute_includes fake.allowable_entities, :request
+      refute_includes fake.allowable_entities, :response
+    end
+    
+    test '#initialize a response-entity-only Method' do
+      fake = Webbed::Method.new('FAKE', :allowable_entities => [:response])
+      refute_includes fake.allowable_entities, :request
+      assert_includes fake.allowable_entities, :response
+    end
+    
+    test '#initialize a two-entity Method' do
+      fake = Webbed::Method.new('FAKE', :allowable_entities => [:request, :response])
+      assert_includes fake.allowable_entities, :request
+      assert_includes fake.allowable_entities, :response
+    end
+    
+    test 'cached Methods' do
+      assert_same Webbed::Method::OPTIONS, Webbed::Method.new('OPTIONS')
+      assert_same Webbed::Method::GET, Webbed::Method.new('GET')
+      assert_same Webbed::Method::HEAD, Webbed::Method.new('HEAD')
+      assert_same Webbed::Method::POST, Webbed::Method.new('POST')
+      assert_same Webbed::Method::PUT, Webbed::Method.new('PUT')
+      assert_same Webbed::Method::DELETE, Webbed::Method.new('DELETE')
+      assert_same Webbed::Method::TRACE, Webbed::Method.new('TRACE')
+      assert_same Webbed::Method::CONNECT, Webbed::Method.new('CONNECT')
+      assert_same Webbed::Method::PATCH, Webbed::Method.new('PATCH')
+    end
+    
+    test 'equality' do
+      fake = Webbed::Method.new('FAKE')
+      
+      assert_equal Webbed::Method.new('FAKE'), fake
+      refute_equal Webbed::Method::POST, fake
+    end
+    
+    test 'OPTIONS' do
+      method = Webbed::Method::OPTIONS
+      
+      assert_equal 'OPTIONS', method.to_s
+      assert method.safe?
+      assert method.idempotent?
+      refute_includes method.allowable_entities, :request
+      assert_includes method.allowable_entities, :response
+    end
+    
+    test 'GET' do
+      method = Webbed::Method::GET
+      
+      assert_equal 'GET', method.to_s
+      assert method.safe?
+      assert method.idempotent?
+      refute_includes method.allowable_entities, :request
+      assert_includes method.allowable_entities, :response
+    end
+    
+    test 'HEAD' do
+      method = Webbed::Method::HEAD
+      
+      assert_equal 'HEAD', method.to_s
+      assert method.safe?
+      assert method.idempotent?
+      refute_includes method.allowable_entities, :request
+      refute_includes method.allowable_entities, :response
+    end
+    
+    test 'POST' do
+      method = Webbed::Method::POST
+      
+      assert_equal 'POST', method.to_s
+      refute method.safe?
+      refute method.idempotent?
+      assert_includes method.allowable_entities, :request
+      assert_includes method.allowable_entities, :response
+    end
+    
+    test 'PUT' do
+      method = Webbed::Method::PUT
+      
+      assert_equal 'PUT', method.to_s
+      refute method.safe?
+      assert method.idempotent?
+      assert_includes method.allowable_entities, :request
+      assert_includes method.allowable_entities, :response
+    end
+    
+    test 'DELETE' do
+      method = Webbed::Method::DELETE
+      
+      assert_equal 'DELETE', method.to_s
+      refute method.safe?
+      assert method.idempotent?
+      refute_includes method.allowable_entities, :request
+      assert_includes method.allowable_entities, :response
+    end
+    
+    test 'TRACE' do
+      method = Webbed::Method::TRACE
+      
+      assert_equal 'TRACE', method.to_s
+      assert method.safe?
+      assert method.idempotent?
+      refute_includes method.allowable_entities, :request
+      assert_includes method.allowable_entities, :response
+    end
+    
+    test 'CONNECT' do
+      method = Webbed::Method::CONNECT
+      
+      assert_equal 'CONNECT', method.to_s
+      refute method.safe?
+      refute method.idempotent?
+      assert_includes method.allowable_entities, :request
+      assert_includes method.allowable_entities, :response
+    end
+    
+    test 'PATCH' do
+      method = Webbed::Method::PATCH
+      
+      assert_equal 'PATCH', method.to_s
+      refute method.safe?
+      refute method.idempotent?
+      assert_includes method.allowable_entities, :request
+      assert_includes method.allowable_entities, :response
+    end
+  end
+end

data/test/webbed/request_test.rb

@@ -0,0 +1,74 @@
+require 'test_helper'
+
+module WebbedTest
+  class RequestTest < TestCase
+    test '#initialize without options' do
+      request = Webbed::Request.new(
+        'POST',
+        'http://google.com',
+        { 'Content-Type' => 'text/plain' },
+        'Test 1 2 3'
+      )
+      
+      assert_equal Webbed::Method::POST, request.method
+      assert_instance_of Addressable::URI, request.request_uri
+      assert_equal 'http://google.com', request.request_uri.to_s
+      assert_equal 'text/plain', request.headers['Content-Type']
+      assert_equal 'Test 1 2 3', request.entity_body
+      assert_equal Webbed::HTTPVersion::ONE_POINT_ONE, request.http_version
+      assert_equal 'http', request.scheme
+    end
+    
+    test '#initialize with an HTTP Version' do
+      request = Webbed::Request.new(
+        'POST',
+        'http://google.com',
+        { 'Content-Type' => 'text/plain' },
+        'Test 1 2 3',
+        :http_version => 1.0
+      )
+      
+      assert_equal Webbed::HTTPVersion::ONE_POINT_OH, request.http_version
+    end
+    
+    test '#initialize with a scheme' do
+      request = Webbed::Request.new(
+        'POST',
+        'http://google.com',
+        { 'Content-Type' => 'text/plain' },
+        'Test 1 2 3',
+        :scheme => 'https'
+      )
+      
+      assert_equal 'https', request.scheme
+    end
+    
+    test '#method' do
+      request = Webbed::Request.new(
+        'POST',
+        'http://google.com',
+        { 'Content-Type' => 'text/plain' },
+        'Test 1 2 3'
+      )
+      
+      request.method = 'GET'
+      
+      assert_instance_of Webbed::Method, request.method
+      assert_equal Webbed::Method::GET, request.method
+      
+      assert_instance_of Method, request.method(:__send__)
+    end
+    
+    test '#scheme' do
+      request = Webbed::Request.new(
+        'POST',
+        'http://google.com',
+        { 'Content-Type' => 'text/plain' },
+        'Test 1 2 3'
+      )
+      
+      request.scheme = 'https'
+      assert_equal 'https', request.scheme
+    end
+  end
+end

data/test/webbed/response_test.rb

@@ -0,0 +1,86 @@
+require 'test_helper'
+
+module WebbedTest
+  class ResponseTest < TestCase
+    test '#initialize without options' do
+      response = Webbed::Response.new(
+        404,
+        { 'Content-Type' => 'text/plain' },
+        'Test 1 2 3'
+      )
+      
+      assert_equal 'text/plain', response.headers['Content-Type']
+      assert_equal 'Test 1 2 3', response.entity_body
+      assert_equal Webbed::HTTPVersion::ONE_POINT_ONE, response.http_version
+    end
+    
+    test '#initialize with a Reason Phrase' do
+      response = Webbed::Response.new(
+        '200 LOLOL',
+        {},
+        'Test 1 2 3'
+      )
+      
+      assert_equal 'LOLOL', response.reason_phrase
+      
+      assert_instance_of Webbed::StatusCode, response.status_code
+      assert_equal 200, response.status_code
+    end
+    
+    test '#initialize without a Reason Phrase' do
+      response = Webbed::Response.new(
+        404,
+        {},
+        'Test 1 2 3'
+      )
+      
+      assert_equal 'Not Found', response.reason_phrase
+      
+      assert_instance_of Webbed::StatusCode, response.status_code
+      assert_equal 404, response.status_code
+    end
+    
+    test '#initialize with an HTTP Version' do
+      response = Webbed::Response.new(
+        404,
+        {},
+        'Test 1 2 3',
+        :http_version => 1.0
+      )
+      
+      assert_equal Webbed::HTTPVersion::ONE_POINT_OH, response.http_version
+    end
+    
+    test '#status_code' do
+      response = Webbed::Response.new(
+        404,
+        {},
+        'Test 1 2 3'
+      )
+      
+      assert_instance_of Webbed::StatusCode, response.status_code
+      assert_equal 404, response.status_code
+      
+      response.status_code = 100
+      
+      assert_instance_of Webbed::StatusCode, response.status_code
+      assert_equal 100, response.status_code
+    end
+    
+    test '#reason_phrase' do
+      response = Webbed::Response.new(
+        500,
+        {},
+        'Test 1 2 3'
+      )
+      
+      assert_equal 'Internal Server Error', response.reason_phrase
+      
+      response.status_code = 404
+      assert_equal 'Not Found', response.reason_phrase
+      
+      response.reason_phrase = 'FOOBAR'
+      assert_equal 'FOOBAR', response.reason_phrase
+    end
+  end
+end