hyperdrive 0.0.5 → 0.0.6

data/spec/hyperdrive/middleware/content_negotiation_spec.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Hyperdrive::Middleware::ContentNegotiation do
+  def app
+    Rack::Builder.new do
+      use Hyperdrive::Middleware::ContentNegotiation
+      map '/' do
+        run ->(env) { [200, {}, ["#{env['hyperdrive.media_type']}"]] }
+      end
+    end
+  end
+
+  before do
+    @resource = default_resource
+    @env = default_rack_env(@resource)
+  end
+
+  it "returns the best supported media type" do
+    get '/', {}, @env
+    last_response.body.must_equal 'application/vnd.hyperdrive.things+hal+json'
+  end
+
+  it "throws an error if the media type requested is not supported" do
+    bad_env = @env.merge('hyperdrive.accept' => Rack::Accept::MediaType.new('application/xml'), 'HTTP_ACCEPT' => 'application/xml')
+    -> { get '/', {}, bad_env }.must_raise Hyperdrive::Errors::NotAcceptable
+  end
+end

data/spec/hyperdrive/middleware/cors_spec.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Hyperdrive::Middleware::CORS do
+  def app
+    cors_options = {
+      origins: '*',
+      allow_headers: '*, Content-Type, Accept, AUTHORIZATION, Cache-Control',
+      credentials: true,
+      expose_headers: 'Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma',
+      max_age: 86400
+    }
+    inner_app = ->(env) { [200, {}, ['']] }
+    Hyperdrive::Middleware::CORS.new(inner_app, cors_options)
+  end
+
+  before do
+    env = default_rack_env(default_resource)
+    get '/', {}, env
+    @headers = last_response.headers
+  end
+
+  it "allows origins" do
+    @headers['Access-Control-Allow-Origin'].must_equal '*'
+  end
+
+  it "allows methods" do
+    @headers['Access-Control-Allow-Methods'].must_equal 'OPTIONS, GET, HEAD'
+  end
+
+  it "allows headers" do
+    @headers['Access-Control-Allow-Headers'].must_equal '*, Content-Type, Accept, AUTHORIZATION, Cache-Control'
+  end
+
+  it "allows credentials" do
+    @headers['Access-Control-Allow-Credentials'].must_equal "true"
+  end
+
+  it "has a max age" do
+    @headers['Access-Control-Max-Age'].must_equal "86400"
+  end
+
+  it "exposes headers" do
+    @headers['Access-Control-Expose-Headers'].must_equal 'Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma'
+  end
+end

data/spec/hyperdrive/middleware/error_spec.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Hyperdrive::Middleware::Error do
+  def app
+    Rack::Builder.new do
+      use Hyperdrive::Middleware::Error
+      run ->(env) { raise Hyperdrive::Errors::HTTPError }
+    end
+  end
+
+  before do
+    @response = %Q({"_links":{"root":{"href":"/","title":"API Root"}},"error":{"type":"HTTPError","message":"Hyperdrive::Errors::HTTPError"}})
+    get '/'
+  end
+
+  it "traps errors" do
+    last_response.status.must_equal 500
+  end
+
+  it "returns a formatted error message" do
+    last_response.body.must_equal @response
+  end
+end

data/spec/hyperdrive/middleware/request_method_spec.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Hyperdrive::Middleware::RequestMethod do
+  def app
+    inner_app = ->(env) { [200, {}, ['']] }
+    Hyperdrive::Middleware::RequestMethod.new(inner_app)
+  end
+
+  before do
+    @resource = default_resource
+    @env = default_rack_env(@resource)
+  end
+
+  it "is successful if the request method is supported" do
+    get '/', {}, @env
+    last_response.successful?.must_equal true
+  end
+
+  it "throws an error if hyperdrive doesn't support the request method" do
+    ->{ request('/', @env.merge('REQUEST_METHOD' => 'TRACE')) }.must_raise Hyperdrive::Errors::NotImplemented
+  end
+
+  it "throws an error if the resource doesn't support the request method" do
+    ->{ post('/', {}, @env.merge('REQUEST_METHOD' => 'POST')) }.must_raise Hyperdrive::Errors::MethodNotAllowed
+  end
+end

data/spec/hyperdrive/middleware/required_params_spec.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Hyperdrive::Middleware::RequiredParams do
+  def app
+    inner_app = ->(env) { [200, {}, [env['hyperdrive.params'][:id]]] }
+    Hyperdrive::Middleware::RequiredParams.new(inner_app)
+  end
+
+  before do
+    @resource = default_resource
+    @env = default_rack_env(@resource).merge('hyperdrive.params' => {})
+    @filters = { parent_id: '1000' }
+  end
+
+  context "Filters" do
+    it "responds successfully if required filter is present" do
+      get '/', @filters, @env.merge('hyperdrive.params' => @filters)
+      last_response.successful?.must_equal true
+    end
+
+    it "raises an error if required filter is missing" do
+      ->{ get '/', {}, @env }.must_raise Hyperdrive::Errors::MissingRequiredParam
+    end
+  end
+
+  context "Params" do
+    before do
+      @env.merge!('REQUEST_METHOD' => 'PUT')
+      @params = { id: '1001', name: 'yoda' }
+    end
+
+    it "responds successfully if required params are present" do
+      put '/', @params, @env.merge('hyperdrive.params' => @params)
+      last_response.successful?.must_equal true
+    end
+
+    it "raises an error if required param is missing" do
+      ->{ put '/', {}, @env }.must_raise Hyperdrive::Errors::MissingRequiredParam
+    end
+  end
+end

data/spec/hyperdrive/middleware/resource_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Hyperdrive::Middleware::Resource do
+  def app
+    inner_app = ->(env) { [200, {}, [env['hyperdrive.resource'].namespace]] }
+    Hyperdrive::Middleware::Resource.new(inner_app, default_resource)
+  end
+
+  it "adds the requested resource to rack's env" do
+    get '/'
+    last_response.body.must_equal "things"
+  end
+end

data/spec/hyperdrive/middleware/sanitize_params_spec.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Hyperdrive::Middleware::SanitizeParams do
+  before do
+    @env = default_rack_env(default_resource)
+  end
+
+  def app
+    inner_app = ->(env) { [200, {}, [env['hyperdrive.params']]] }
+    Hyperdrive::Middleware::SanitizeParams.new(inner_app)
+  end
+
+  it "will sanitize filters" do
+    get '/', { 'id' => '1001', 'removed' => 'me' }, @env
+    last_response.body.must_equal "{:id=>\"1001\"}"
+  end
+
+  it "will sanitize params" do
+    post '/', { 'id' => '1001', 'removed' => 'me' }, @env
+    last_response.body.must_equal "{:id=>\"1001\"}"
+  end
+end

data/spec/hyperdrive/param_spec.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Hyperdrive::Param do
+  before do
+    @param = default_param
+  end
+
+  it "has a name" do
+    @param.name.must_equal 'id'
+  end
+
+  it "has a description" do
+    @param.description.must_equal 'Identifier'
+  end
+
+  it "returns an array of HTTP methods it's required for" do
+    @param.required.must_equal %w(PUT PATCH DELETE)
+  end
+
+  it "returns true if the param is required for the given HTTP method" do
+    @param.required?('PUT').must_equal true
+  end
+
+  it "returns false if the param is not required for the given HTTP method" do
+    @param.required?('POST').must_equal false
+  end
+
+  it "converts itself as a hash" do
+    constraints = { name: 'id', description: 'Identifier', type: 'String', constraints: 'Required for: PUT, PATCH, DELETE. Must be a valid BSON Object ID.' }
+    @param.to_hash.must_equal constraints
+  end
+end

data/spec/hyperdrive/resource_spec.rb

@@ -2,7 +2,27 @@ require 'spec_helper'
 
 describe Hyperdrive::Resource do
   before do
-    @resource = Hyperdrive::Resource.new(:thing)
+    @resource = Hyperdrive::Resource.new(:thing, { vendor: 'hyperdrive', media_types: ['json'] })
+    @resource.register_param(:name, 'Thing Name')
+    @resource.register_filter(:parent_id, 'Parent ID', required: true)
+    @resource.register_request_handler(:get, Proc.new { |env| 'v1' })
+    @resource.register_request_handler(:get, Proc.new { |env| 'v2' }, 'v2')
+    @media_types = ["application/vnd.hyperdrive.things.v2+json",
+                    "application/vnd.hyperdrive.things.v1+json",
+                    "application/vnd.hyperdrive.things+json",
+                    "application/vnd.hyperdrive+json"]
+  end
+
+  it "has an ID" do
+    @resource.id.must_equal "hyperdrive:things"
+  end
+
+  it "has a namespace" do
+    @resource.namespace.must_equal 'things'
+  end
+
+  it "has an endpoint" do
+    @resource.endpoint.must_equal '/things'
   end
 
   it "has a name" do
@@ -11,57 +31,99 @@ describe Hyperdrive::Resource do
   end
 
   it "has a description" do
-    @resource.desc = 'Description of Thing Resource'
-    @resource.desc.must_equal 'Description of Thing Resource'
+    @resource.description = 'Thing Description'
+    @resource.description.must_equal 'Thing Description'
   end
 
-  it "has an endpoint" do
-    @resource.endpoint.must_equal '/things'
+  it "auto-registers the :id param" do
+    @resource.params[:id].description.must_equal 'Identifier'
   end
 
-  it "auto-registers the :id param" do
-    @resource.allowed_params[:id][:desc].must_equal 'Resource Identifier'
-    @resource.allowed_params[:id][:required].must_equal %w(PUT PATCH DELETE)
+  it "registers a param" do
+    @resource.params[:name].description.must_equal 'Thing Name'
   end
 
-  it "registers an allowed param" do
-    @resource.register_param(:name, "Thing's Name")
-    @resource.allowed_params[:name][:desc].must_equal "Thing's Name"
-    @resource.allowed_params[:name][:required].must_equal true
+  it "returns true if the param is required for the given HTTP Method" do
+    @resource.required_param?(:name, 'POST').must_equal true
+  end
+
+  it "returns false if the param is not required for the given HTTP Method" do
+    @resource.required_param?(:name, 'DELETE').must_equal false
   end
 
   it "auto-registers the :id filter" do
-    @resource.filters[:id][:desc].must_equal 'Resource Identifier'
-    @resource.filters[:id][:required].must_equal false
+    @resource.filters[:id].description.must_equal 'Resource Identifier'
   end
 
   it "registers a filter" do
-    @resource.register_filter(:parent_id, 'Parent ID of Thing', required: true)
-    @resource.filters[:parent_id][:desc].must_equal 'Parent ID of Thing'
-    @resource.filters[:parent_id][:required].must_equal true
+    @resource.filters[:parent_id].description.must_equal 'Parent ID'
+  end
+
+    it "returns true if the filter is required for the given HTTP Method" do
+    @resource.required_filter?(:parent_id, 'GET').must_equal true
+  end
+
+  it "returns false if the filter is not required for the given HTTP Method" do
+    @resource.required_filter?(:parent_id, 'OPTIONS').must_equal false
+  end
+
+  it "returns true if the param (or filter) is required" do
+    @resource.required?(:name, 'POST').must_equal true
+  end
+
+  it "returns true if the filter (or param) is required" do
+    @resource.required?(:parent_id, 'GET').must_equal true
+  end
+
+  it "returns false if the param (or filter) is not required" do
+    @resource.required?(:name, 'GET').must_equal false
   end
 
-  it "defines a request handler" do
-    @resource.define_request_handler(:get, Proc.new { return 'ok' })
-    @resource.request_handlers[:get].call.must_equal 'ok'
+  it "returns false if the filter (or param) is not required" do
+    @resource.required?(:parent_id, 'DELETE').must_equal false
+  end
+
+  it "registers a request handler" do
+    @resource.request_handlers[:get]['v1'].must_be :===, Proc
+  end
+
+  it "auto-registers HEAD request handler when GET handler is registered" do
+    @resource.request_handlers[:head]['v1'].must_be :===, Proc
   end
 
   it "returns the specified request handler" do
-    @resource.define_request_handler(:get, Proc.new { return 'ok' })
-    @resource.request_handler('GET').call.must_equal 'ok'
+    @resource.request_handler('GET').must_be :===, Proc
   end
 
   it "returns true if the request can be handled" do
-    @resource.define_request_handler(:get, Proc.new { return 'ok' })
     @resource.request_method_allowed?('GET').must_equal true
   end
 
   it "returns false if the request can not be handled" do
-    @resource.request_method_allowed?('GET').must_equal false
+    @resource.request_method_allowed?('POST').must_equal false
   end
 
   it "returns the request methods that can handled" do
-    @resource.define_request_handler(:get, Proc.new { return 'ok' })
     @resource.allowed_methods.must_equal ['OPTIONS','GET','HEAD']
   end
+
+  it "returns the request handler for the specified version" do
+    @resource.request_handler('GET', 'v2').must_be :===, Proc
+  end
+
+  it "returns the acceptable content types" do
+    @resource.acceptable_content_types('GET').must_equal @media_types
+  end
+
+  it "returns the available versions for this resource" do
+    @resource.available_versions('GET').must_equal ['v2','v1']
+  end
+
+  it "returns the latest available version for this resource" do
+    @resource.latest_version('GET').must_equal 'v2'
+  end
+
+  it "returns a hash representation of the resource" do
+    @resource.to_hash.must_be_kind_of Hash
+  end
 end

data/spec/hyperdrive/server_spec.rb

@@ -1,11 +1,52 @@
 # encoding: utf-8
 
+require 'spec_helper'
+
 describe Hyperdrive::Server do
-  it "handles GET requests successfully"
-  it "handles HEAD requests successfully"
-  it "handles OPTIONS requests successfully"
-  it "handles POST requests successfully"
-  it "handles PUT requests successfully"
-  it "handles PATCH requests successfully"
-  it "handles DELETE requests successfully"
+  def app
+    Hyperdrive::Server
+  end
+
+  before do
+    sample_api
+  end
+
+  after do
+    hyperdrive.send(:reset!)
+  end
+
+  it "responds to GET requests successfully" do
+    get '/things', { parent_id: 42 }
+    last_response.successful?.must_equal true
+  end
+
+  it "responds to HEAD requests successfully" do
+    head '/things', { parent_id: 42 }
+    last_response.successful?.must_equal true
+  end
+
+  it "responds to OPTIONS requests successfully" do
+    options '/things'
+    last_response.successful?.must_equal true
+  end
+
+  it "responds to POST requests successfully" do
+    post '/things', { name: 'bender' }
+    last_response.successful?.must_equal true
+  end
+
+  it "responds to PUT requests successfully" do
+    put '/things', { id: 1, name: 'bender' }
+    last_response.successful?.must_equal true
+  end
+
+  it "responds to PATCH requests successfully" do
+    patch '/things', { id: 1, name: 'bender' }
+    last_response.successful?.must_equal true
+  end
+
+  it "responds to DELETE requests successfully" do
+    delete '/things', { id: 1 }
+    last_response.successful?.must_equal true
+  end
 end

data/spec/hyperdrive/utils_spec.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Hyperdrive::Utils do
+  context '.sanitize_keys' do
+    before do
+      @subject = Hyperdrive::Utils.sanitize_keys([:keep], { keep: 'this', remove: 'that' })
+    end
+
+    it "removes keys that were specified from the given hash" do
+      @subject.key?(:remove).must_equal false
+    end
+
+    it "keeps keys that were not specified from the given hash" do
+      @subject.key?(:keep).must_equal true
+    end
+  end
+
+  context '.symbolize_keys' do
+    before do
+      @hash = { 'string' => 'cheese', 'collection' => [{'skylanders' => 155}], 'map' => { 'oceans' => 'blue' } }
+      @subject = Hyperdrive::Utils.symbolize_keys(@hash)
+    end
+
+    it "can symbolize the keys of a hash" do
+      @subject[:string].must_equal 'cheese'
+    end
+
+    it "can symbolize the keys of nested hashes" do
+      @subject[:map][:oceans].must_equal 'blue'
+    end
+
+    it "can symbolize the keys of arrays of hashes" do
+      @subject[:collection].first[:skylanders].must_equal 155
+    end
+  end
+end

data/spec/hyperdrive/values_spec.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Hyperdrive::Values do
+  before do
+    @values = Hyperdrive::Values
+  end
+
+  it "returns a list of request methods that are definable" do
+    @values.definable_request_methods.must_be_kind_of Array
+  end
+
+  it "returns a list of request_methods that are supported" do
+    @values.supported_request_methods.must_be_kind_of Array
+  end
+
+  it "returns a map of request methods to http request methods" do
+    @values.request_methods.must_be_kind_of Hash
+  end
+
+  it "returns a map of http request methods to request methods" do
+    @values.http_request_methods.must_be_kind_of Hash
+  end
+
+  it "returns a map of default cors options" do
+    @values.default_cors_options.must_be_kind_of Hash
+  end
+
+  it "returns a map of default config options" do
+    @values.default_cors_options.must_be_kind_of Hash
+  end
+
+  it "returns a map of default headers" do
+    @values.default_cors_options.must_be_kind_of Hash
+  end
+end

data/spec/spec_helper.rb

@@ -1,5 +1,9 @@
 # encoding: utf-8
 
+require 'rubinius/coverage' if RUBY_ENGINE == 'rubinius'
+require "codeclimate-test-reporter"
+CodeClimate::TestReporter.start
+
 # bootstrap the environment
 ENV['RACK_ENV'] = 'test'
 lib_path = File.expand_path('../lib', __FILE__)
@@ -13,27 +17,82 @@ Bundler.setup(:default, ENV['RACK_ENV'])
 require 'hyperdrive'
 
 # Fire up the BDD Stack
+require 'rack/test'
 require 'minitest/autorun'
 require "minitest-spec-context"
 require 'minitest/reporters'
 
 #  all systems go
 MiniTest::Reporters.use! MiniTest::Reporters::SpecReporter.new
-#include Rack::Test::Methods
+include Rack::Test::Methods
+
+module Hyperdrive
+  module TestData
+    def default_rack_env(resource = nil)
+      default_env = {
+        "rack.version" => Rack::VERSION,
+        "rack.input" => StringIO.new,
+        "rack.errors" => StringIO.new,
+        "rack.multithread" => true,
+        "rack.multiprocess" => true,
+        "rack.run_once" => false,
+        'HTTP_ACCEPT_CHARSET' => 'UTF-8',
+        'HTTP_ACCEPT' => 'application/vnd.hyperdrive.things+hal+json;q=0.8, application/json;q=1',
+        'HTTP_ACCEPT_LANGUAGE' => 'en',
+        'REQUEST_METHOD' => 'GET',
+        'QUERY_STRING' => 'id=1001'
+      }
+      default_env.merge!('hyperdrive.accept' => Rack::Accept::MediaType.new(default_env['HTTP_ACCEPT']))
+      default_env.merge!('hyperdrive.resource' => resource) if resource
+      default_env
+    end
+
+    def default_resource
+      resource = Hyperdrive::Resource.new(:thing, { vendor: 'hyperdrive', media_types: ['hal+json', 'json'] })
+      resource.register_request_handler(:get, Proc.new { |env| }, 'v1')
+      resource.register_filter(:parent_id, '', required: true)
+      resource
+    end
+
+    def default_filter
+      Hyperdrive::Filter.new(:parent_id, 'Parent Identifier', required: true, constraints: 'Must be a valid BSON Object ID.')
+    end
+
+    def default_param
+      Hyperdrive::Param.new(:id, 'Identifier', required: %w(PUT PATCH DELETE), constraints: 'Must be a valid BSON Object ID.')
+    end
+
+    def sample_api
+      hyperdrive do
+        resource(:thing) do
+          name 'Thing Resource'
+          description 'Description of Thing Resource'
+
+          param :name, '50 Chars or less', required: true
+          filter :parent_id, 'Parent ID of Thing', required: true
+
+          request(:get) do
+            'ok'
+          end
+
+          request(:post) do
+            'ok'
+          end
 
-def sample_api
-  hyperdrive do
-    resource(:thing) do
-      name 'Thing Resource'
-      desc 'Description of Thing Resource'
+          request(:put) do
+            'ok'
+          end
 
-      param :name, '50 Chars or less' 
-      param :start_date, 'Format: YYYY-MM-DD', required: false
-      param :end_date, 'Format: YYYY-MM-DD', required: false
+          request(:patch) do
+            'ok'
+          end
 
-      filter :start_date, 'Format: YYYY-MM-DD'
-      filter :end_date, 'Format: YYYY-MM-DD'
-      filter :parent_id, 'Parent ID of Thing', required: true
+          request(:delete) do
+            ''
+          end
+        end
+      end
     end
   end
 end
+include Hyperdrive::TestData