sinatra-rest-base 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b9af7fb5e0df73f24103bb5b39ea04ff158da525
+  data.tar.gz: 163aa0d3b19c1602dc156774e8ed3d78068e9471
+SHA512:
+  metadata.gz: ad4876e275d150164b2b7deabf58de1b1ee57ada749377740ff861cb3548d02a9944c9c1eddc90960d4e9d890fcd9fb9a93905dcd6ef1a5bf3c5474ab8f21829
+  data.tar.gz: 9a912cb5fff19ba832be1bb90bc5e7d9d4346569fe944b7f253e9f862e4940b9bfd61e8de4ff4067f5a7c420b23a009df61b3855138a8908a498053751e244d2

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in sintara-rest-base.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 bmills
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,77 @@
+# Rest
+
+Core base classes for quick configuration of Sinatra for RESTful Services
+
+#### What Does the Core Cover
+
+* Adherence to [API Standards] (https://github.com/RESTful-Forest/Sinatra-Rest-Base/wiki/RESTful-API-Standards)
+* Basic Configuration
+  * Storing the IO String Request Body into a global hash 'request_body'
+  * Processing the response body into the proper accepted mime type (application/json, text/xml, ect.) depending on the HTTP_ACCEPT header.
+      * Defaults to application/json
+  * Processing the version of the application being accessed via HTTP_ACCEPT header
+* Basic Error Handeling
+  * Handles Authentication Errors, StandardError, Error status codes 400..510
+  * Implements Basic Error Classes
+    * InvalidRequest
+    * More to come soon!
+* Simple authentication setup
+  * Provides a base authentication class to inherit from and create a quick authentication process.
+  * Provides an easy authentication setup through the configuration setup of Sinatra.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'sinatra-rest-base'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install sinatra-rest-base
+
+## Usage
+
+#### Setting Up the Application 
+
+Normal Sinatra Appication inherit from either Sinatra::Application or Sinatra::Base. With sinatra-rest-base you just need to inherit from Rest::Application.
+
+In your main application file, do the following:
+
+```
+require 'rest'
+
+class SinatraApp < Rest::Application
+end
+```
+
+then in any other partial class file of the main application file, you just have to name the class like follow:
+
+```
+require 'rest'
+
+class SinatraApp
+
+  get '/' do
+    {
+      :result => "This is so easy now!"
+    }
+  end
+
+end
+```
+
+Bam, that easy!
+
+## [Documentation Wiki] (https://github.com/RESTful-Forest/Sinatra-Rest-Base/wiki/Documentation)
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/sintara-rest-base/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lib/rest/application.rb

@@ -0,0 +1,42 @@
+require 'sinatra/base'
+require 'json'
+require 'active_support'
+require 'active_support/core_ext/hash'
+require 'rest/authentication'
+
+module Rest
+  class Application < Sinatra::Base
+    attr_reader :request_body
+    attr_reader :request_version
+    attr_reader :errored
+
+    configure do
+      disable :raise_errors
+      disable :show_exceptions
+      set :api_version, 1
+      set :authentication, Rest::Authentication::BasicAuthentication.new([])
+      disable :header_versioning
+    end
+
+    set(:version) do |value|
+      condition do
+        has_version?("version=#{value}")
+      end
+    end
+
+    before do
+      status 200
+
+      set_api_version if settings.header_versioning
+      set_request_body
+      error 401 unless authenticated?
+    end
+
+    after do
+      response.body = nil if response.body.is_a?(Array) && response.body.length == 1 && response.body[0].empty?     
+      response.body = create_response()
+      
+      response.headers['Content-Type'] += ";version=#{@request_version}"
+    end
+  end
+end

data/lib/rest/application_helper.rb

@@ -0,0 +1,65 @@
+module Rest
+  class Application < Sinatra::Base
+    def authenticated?
+      authorized = true
+      authorized = settings.authentication.authorized?(request, @env['HTTP_AUTHORIZATION']) unless settings.authentication.nil?
+      authorized
+    end
+    
+    def has_version?(version)
+      @env['HTTP_ACCEPT'] = "*/*" if @env['HTTP_ACCEPT'].nil?
+      @env['HTTP_ACCEPT'].include?(version)
+    end
+
+    def get_version
+      matchdata = @env['HTTP_ACCEPT'].to_s.scan(/(version)=(\d*)/)
+      matchdata[0][1].delete(',').to_f
+    end
+
+    def set_api_version
+      @env['HTTP_ACCEPT'] += ";version=#{settings.api_version}" unless has_version?("version=")
+      @env['sinatra.accept'] = nil
+      @request_version = get_version
+    end
+
+    def set_request_body
+      read_body = request.body.read
+
+      if read_body.empty?
+        @request_body = {}
+      elsif request.media_type.downcase == 'text/xml'
+        @request_body = Hash.from_xml(read_body)
+        @request_body = Hash[@request_body.map{ |k, v| [k.to_sym, v] }]
+        @request_body = @request_body[:request]
+      else
+        @request_body = JSON.parse(read_body, :symbolize_names => true)
+      end
+    end
+    
+    def create_response()
+      content_type :json
+      content_type :xml if !request.accept?('*/*') && request.accept?('text/xml')
+      
+      if (response.status >= 400)
+        error_hash = response.body
+        error_hash = [error_hash] if error_hash.is_a?(String)
+
+        response.body = nil
+      end
+      
+      response_hash = {
+        :errors => error_hash,
+        :results => response.body
+      }
+      
+      return '' if empty_body_status_code? && (response.body.empty?)
+      return response_hash.to_xml(:root => :response) if response.headers['Content-Type'].start_with? 'application/xml;'
+      response_hash.to_json
+    end
+    
+    def empty_body_status_code?
+      empty_body_status_codes = [201, 204, 304]
+      response != nil && empty_body_status_codes.include?(response.status)
+    end
+  end
+end

data/lib/rest/authentication/authentication_base.rb

@@ -0,0 +1,9 @@
+module Rest
+  module Authentication
+    class AuthenticationBase
+      def authorized?(request, key)
+        true
+      end
+    end
+  end
+end

data/lib/rest/authentication/basic_authentication.rb

@@ -0,0 +1,15 @@
+module Rest
+  module Authentication
+    class BasicAuthentication < AuthenticationBase
+      def initialize(keys)
+        @valid_keys = keys
+      end
+
+      def authorized?(request, key)
+        authorized = true
+        authorized = @valid_keys.include?(key) unless @valid_keys.length == 0
+        authorized
+      end
+    end
+  end
+end

data/lib/rest/authentication.rb

@@ -0,0 +1,7 @@
+module Rest
+  module Authentication
+    
+  end
+end
+
+Gem.find_files('rest/authentication/*.rb').each { |path| require path }

data/lib/rest/error_handeling.rb

@@ -0,0 +1,17 @@
+require 'sinatra/base'
+require 'rest/exceptions'
+
+module Rest
+  class Application < Sinatra::Base
+    error Rest::Exceptions::InvalidRequest do
+      cur_error = env["sinatra.error"]
+      errors = [cur_error.message]
+
+      cur_error.invalid_params.each { |param, message|
+        errors << "#{param.to_s} is not valid: #{message}"
+      }
+
+      errors
+    end
+  end
+end

data/lib/rest/error_status_handeling.rb

@@ -0,0 +1,23 @@
+module Rest
+  class Application < Sinatra::Base
+    not_found do
+      response.body = 'Endpoint not found'
+    end
+
+    error 401 do
+      response.body = 'Unauthorized Access'
+      create_response()
+    end
+    
+    error 404 do
+      response.body = "Endpoint not found"
+      create_response()
+    end
+
+    error 500 do
+      return @env['sinatra.error'].message unless @env['sinatra.error'].nil?
+      response.body = 'Internal Error'
+      create_response()
+    end
+  end
+end

data/lib/rest/exceptions/invalid_request.rb

@@ -0,0 +1,12 @@
+module Rest
+  module Exceptions
+    class InvalidRequest < StandardError
+      attr_reader :invalid_params
+      
+      def initialize(invalid_params)
+        @invalid_params = invalid_params
+        super "Invalid Request Format"
+      end
+    end
+  end
+end

data/lib/rest/exceptions.rb

@@ -0,0 +1,6 @@
+module Rest
+  module Exceptions
+  end
+end
+
+Gem.find_files('rest/exceptions/*.rb').each { |path| require path }

data/lib/rest/version.rb

@@ -0,0 +1,3 @@
+module Rest
+  VERSION = "0.1.0"
+end

data/lib/rest.rb

@@ -0,0 +1,5 @@
+module Rest
+  
+end
+
+Gem.find_files('rest/*.rb').each { |path| require path }

data/sinatra-rest-base.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rest/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "sinatra-rest-base"
+  spec.version       = Rest::VERSION
+  spec.authors       = ["bmills"]
+  spec.email         = ["brandon.mills@careerbuilder.com"]
+  spec.summary       = %q{Base class for quickly setting up RESTful services through Sinatra.}
+  spec.description   = %q{Base class for quickly setting up RESTful services through Sinatra.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  
+  spec.add_dependency "json", "~> 1.8"
+  spec.add_dependency "sinatra", "~> 1.4"
+  spec.add_dependency "thin", "~> 1.6"  
+  spec.add_dependency "activesupport", "~> 4.1"
+  spec.add_dependency "builder", "~> 3.2"
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rack-test", "~> 0.6"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "simplecov", "~> 0.8"
+end

data/spec/fixtures/test_application.rb

@@ -0,0 +1,11 @@
+module Rest
+  module Test
+    class TestApplication < Rest::Application
+      configure do
+        enable :raise_errors
+        set :authentication, Rest::Authentication::BasicAuthentication.new(['key1', 'key2'])
+        enable :header_versioning
+      end
+    end
+  end
+end

data/spec/fixtures/test_end_points.rb

@@ -0,0 +1,60 @@
+module Rest
+  module Test
+    class TestApplication
+      get '/', :version => 1 do
+        {
+          :gotten => "success"
+        }
+      end
+
+      get '/', :version => 2 do
+        {
+          :gotten => "success 2"
+        }
+      end
+
+      get '/empty', :version => 1 do
+        ""
+      end
+      
+      get '/created', :version => 1 do
+        status 201
+      end
+      
+      get '/nocontent', :version => 1 do
+        status 204
+      end
+      
+      get '/notmodified', :version => 1 do
+        status 304
+      end
+      
+      get '/created_with_body', :version => 1 do
+        status 201
+        { :created => true }
+      end
+
+      post '/', :version => 1 do
+        {
+          :posted => request_body
+        }
+      end
+
+      put '/', :version => 1 do
+        {
+          :updated => request_body
+        }
+      end
+
+      delete '/', :version => 1 do
+        {
+          :deleted => request_body
+        }
+      end
+      
+      delete '/nocontent', :version => 1 do
+        status 204
+      end
+    end
+  end
+end

data/spec/fixtures/test_errors_end_points.rb

@@ -0,0 +1,34 @@
+module Rest
+  module Test
+    class TestApplication
+      get '/invalid_request', :version => 1 do
+        param_errors = {
+          :param1 => "Must be a String",
+          :param2 => "Must be an Integer"
+        }
+
+        raise Rest::Exceptions::InvalidRequest.new(param_errors)
+      end
+
+      get '/unauthorized', :version => 1 do
+        error 401
+      end
+
+      get '/internal_error', :version => 1 do
+        error 500
+      end
+
+      get '/internal_error_raised', :version => 1 do
+        raise StandardError.new("Raised Internal Error")
+      end
+
+      get '/default_error_handeling', :version => 1 do
+        error 400, "This is the default error handler"
+      end
+      
+      get '/hashed_error_handeling', :version => 1 do
+        error 400, { :error => "This is the hashed error handler" }
+      end
+    end
+  end
+end

data/spec/lib/rest/application_spec.rb

@@ -0,0 +1,184 @@
+require 'spec_helper'
+
+describe Rest::Application do
+  before(:each) do
+    @headers = { 'HTTP_AUTHORIZATION' => 'key1' }  
+  end
+  
+  describe :version do
+    it "should set the version to latest when not given" do
+      expected_version = "version=1"
+      
+      get '/', {}, @headers
+      
+      expect(last_request.env["HTTP_ACCEPT"].include? expected_version).to be_truthy
+      expect(last_response.headers["Content-Type"].include? expected_version).to be_truthy
+    end
+    
+    it "should get the version 1 version" do
+      expected_version = "version=1"
+      @headers['HTTP_ACCEPT'] = "application/json;#{expected_version}"
+      
+      get '/', {}, @headers
+      
+      expect(last_request.env["HTTP_ACCEPT"].include? expected_version).to be_truthy
+      expect(last_response.headers["Content-Type"].include? expected_version).to be_truthy
+      expect(last_response.body).to eq({:errors => nil, :results => { :gotten => "success" }}.to_json)
+    end
+    
+    it "should get the version 2 version" do
+      expected_version = "version=2"
+      @headers['HTTP_ACCEPT'] = expected_version
+      
+      get '/', {}, @headers
+      
+      expect(last_request.env["HTTP_ACCEPT"].include? expected_version).to be_truthy
+      expect(last_response.headers["Content-Type"].include? expected_version).to be_truthy
+      expect(last_response.body).to eq({:errors => nil, :results => { :gotten => "success 2" }}.to_json)
+    end
+  end
+  
+  describe :authorization do
+    it "should try to authorize" do
+      get '/', {}, @headers
+    end
+  end
+  
+  describe :status do
+    it "should return status code 200" do
+      get '/', {}, @headers
+      
+      expect(last_response.status).to eq(200)
+    end
+  end
+  
+  describe :empty_response do
+    it "should return an empty string response" do
+      get '/empty', {}, @headers
+      
+      expect(last_response.body).to eq({:errors => nil, :results => nil}.to_json)
+    end
+  end
+  
+  describe :no_content do
+    it "should return a no content response with empty body" do
+      get '/nocontent', {}, @headers
+      
+      expect(last_response.status).to eq(204)
+      expect(last_response.body).to be_empty
+    end
+    
+    it "should return a created response with empty body" do
+      get '/created', {}, @headers
+      
+      expect(last_response.status).to eq(201)
+      expect(last_response.body).to be_empty
+    end
+    
+    it "shoud return a created response with body" do
+      get '/created_with_body', {}, @headers
+      
+      expect(last_response.status).to eq(201)
+      expect(last_response.body).to eq({:errors => nil, :results => {:created => true}}.to_json)
+    end
+    
+    it "should return a not modified response with empty body" do
+      get '/notmodified', {}, @headers
+      
+      expect(last_response.status).to eq(304)
+      expect(last_response.body).to be_empty
+    end
+    
+    it "should delete and return a no content response with empty body" do
+      delete '/nocontent', {}, @headers
+      
+      expect(last_response.status).to eq(204)
+      expect(last_response.body).to be_empty
+    end
+  end
+  
+  describe :json do
+    before(:each) do
+      @posted_body =  { :success => true }
+      
+      @expected_hash = {:errors => nil, :results => { :posted => @posted_body }}
+    end
+    
+    it "should get json" do
+      @expected_hash = {:errors => nil, :results => { :gotten => "success" }}
+      
+      get '/', {}, @headers
+      
+      expect(last_response.body).to eq(@expected_hash.to_json)
+    end
+    
+    it "should set the request body to json" do  
+      @headers['CONTENT_TYPE'] = 'application/json'
+      
+      post '/', @posted_body.to_json, @headers
+      
+      expect(last_response.body).to eq(@expected_hash.to_json)
+    end
+    
+    it "should post xml and return json" do
+      @headers['CONTENT_TYPE'] = 'text/xml'
+      post '/', @posted_body.to_xml(:root => :request), @headers
+      
+      expect(last_response.body).to eq(@expected_hash.to_json)
+    end
+    
+    it "should post empty json and return json" do
+      post '/', "", @headers
+      
+      @expected_hash[:results][:posted] = {}
+      expect(last_response.body).to eq(@expected_hash.to_json)
+    end
+    
+    it "should post json with json string as body" do
+      post '/', @posted_body.to_json, @headers
+      
+      expect(last_response.body).to eq(@expected_hash.to_json)
+    end
+  end
+  
+  describe :xml do
+    before(:each) do
+      @posted_body =  { :success => true }
+      
+      @expected_hash = {:errors => nil, :results => { :posted => @posted_body }}
+    end
+    
+    it "should get xml" do
+      @headers['HTTP_ACCEPT'] = 'text/xml'
+      @expected_hash = { :errors => nil, :results => { :gotten => 'success'} }
+      
+      get '/', {}, @headers
+      
+      expect(last_response.body).to eq(@expected_hash.to_xml(:root => :response))
+    end
+    
+    it "should set the request body to xml" do  
+      @headers['CONTENT_TYPE'] = 'text/xml'
+      @headers['HTTP_ACCEPT'] = 'text/xml'
+      post '/', @posted_body.to_xml(:root => :request), @headers
+      
+      expect(last_response.body).to eq(@expected_hash.to_xml(:root => :response))
+    end
+    
+    it "should post json and return xml" do
+      @headers['CONTENT_TYPE'] = 'application/json'
+      @headers['HTTP_ACCEPT'] = 'text/xml'
+      post '/', @posted_body.to_json, @headers
+      
+      expect(last_response.body).to eq(@expected_hash.to_xml(:root => :response))
+    end
+    
+    it "should post json with json string as body" do
+      @headers['CONTENT_TYPE'] = 'text/xml'
+      @headers['HTTP_ACCEPT'] = 'text/xml'
+      post '/', @posted_body.to_xml(:root => :request), @headers
+      
+      expect(last_response.body).to eq(@expected_hash.to_xml(:root => :response))
+    end
+  end
+end

data/spec/lib/rest/authentication/authentication_base_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Rest::Authentication::AuthenticationBase do
+  describe :authorized? do
+    it "should always be true" do
+      target = Rest::Authentication::AuthenticationBase.new
+      
+      expect(target.authorized?(nil, 'key')).to be_truthy
+    end
+  end
+end

data/spec/lib/rest/authentication/basic_authentication_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Rest::Authentication::BasicAuthentication do
+  describe :initialize do
+    it "should initialize with valid keys" do
+      expected_keys = ['key1', 'key2']
+      target = Rest::Authentication::BasicAuthentication.new(expected_keys)
+      
+      expect(target.instance_variable_get(:@valid_keys)).to eq(expected_keys)
+    end
+  end
+  
+  describe :authorized? do
+    it "should authorized if empty valid array" do
+      target = Rest::Authentication::BasicAuthentication.new([])
+      expect(target.authorized?(nil, 'key')).to be_truthy
+    end
+    
+    it "should authorize the given key" do
+      target = Rest::Authentication::BasicAuthentication.new(['key1', 'key2'])
+      expect(target.authorized?(nil, 'key1')).to be_truthy
+    end
+    
+    it "should authorize the given key" do
+      target = Rest::Authentication::BasicAuthentication.new(['key1', 'key2'])
+      expect(target.authorized?(nil,'key')).to_not be_truthy
+    end
+  end
+end

data/spec/lib/rest/error_handeling_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Rest::Application do
+  before(:each) do
+    @headers = { 'HTTP_AUTHORIZATION' => 'key1' }  
+  end
+  
+  describe :invalid_request do
+    it "should return the invalid param messages" do
+      expected_body = {
+        :errors => [
+          "Invalid Request Format",
+          "param1 is not valid: Must be a String",
+          "param2 is not valid: Must be an Integer"
+        ],
+        :results => nil
+      }
+      
+      get '/invalid_request', {}, @headers
+      
+      expect(last_response.body).to eq(expected_body.to_json)
+    end
+  end
+end

data/spec/lib/rest/error_status_handeling_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+describe Rest::Application do
+  before(:each) do
+    @expected_body = {
+      :errors => [],
+      :results => nil
+    }
+    
+    @headers = { 'HTTP_AUTHORIZATION' => 'key1' }  
+  end
+  
+  describe :error_default_handler do
+    it "should create a error response based on the body" do
+      @expected_body[:errors] << "This is the default error handler"
+      
+      get '/default_error_handeling', {}, @headers
+      
+      expect(last_response.status).to eq(400)
+      expect(last_response.body).to eq(@expected_body.to_json)
+    end
+    
+    it "should create a hashed error response based on the body" do
+      @expected_body[:errors] = { :error => "This is the hashed error handler" }
+      
+      get '/hashed_error_handeling', {}, @headers
+      
+      expect(last_response.status).to eq(400)
+      expect(last_response.body).to eq(@expected_body.to_json)
+    end
+  end
+  
+  describe :error_404 do
+    it "should provide endpoint not found error" do
+      @expected_body[:errors] << "Endpoint not found"
+      
+      get '/not_found', {}, @headers
+      
+      expect(last_response.status).to eq(404)
+      expect(last_response.body).to eq(@expected_body.to_json)
+    end
+  end
+  
+  describe :error_401 do
+    before (:each) do
+      @expected_body[:errors] << "Unauthorized Access" 
+    end
+    
+    it "should create an unauthorized error in json" do
+      get '/unauthorized', {}, @headers
+      
+      expect(last_response.status).to eq(401)
+      expect(last_response.body).to eq(@expected_body.to_json)
+    end
+    
+    it "shoud create an unauthorized error in xml" do
+      @headers['HTTP_ACCEPT'] = 'text/xml'
+      get '/unauthorized', {}, @headers
+      
+      expect(last_response.status).to eq(401)
+      expect(last_response.body).to eq(@expected_body.to_xml(:root => :response))
+    end
+  end
+  
+  describe :error_500 do
+    it "should create an array of errors with the error message in json when halted" do
+      @expected_body[:errors] << "Internal Error"
+      
+      get '/internal_error', {}, @headers
+      
+      expect(last_response.status).to eq(500)
+      expect(last_response.body).to eq(@expected_body.to_json)
+    end
+    
+    it "should create an array of errors with the error message in xml when halted" do
+      @expected_body[:errors] << "Internal Error"
+      
+      @headers['HTTP_ACCEPT'] = 'text/xml'
+      get '/internal_error', {}, @headers
+      
+      expect(last_response.status).to eq(500)
+      expect(last_response.body).to eq(@expected_body.to_xml(:root => :response))
+    end
+    
+    it "should create an array of errors with the error message in json when raised" do
+      @expected_body[:errors] << "Raised Internal Error"
+      
+      get '/internal_error_raised', {}, @headers
+      
+      expect(last_response.status).to eq(500)
+      expect(last_response.body).to eq(@expected_body.to_json)
+    end
+    
+    it "should create an array of errors with the error message in xml when raised" do
+      @expected_body[:errors] << "Raised Internal Error"
+      
+      @headers['HTTP_ACCEPT'] = 'text/xml'
+      get '/internal_error_raised', {}, @headers
+      
+      expect(last_response.status).to eq(500)
+      expect(last_response.body).to eq(@expected_body.to_xml(:root => :response))
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+require 'simplecov'
+require 'rack/test'
+require 'json'
+
+SimpleCov.start do
+  add_filter '/spec/'
+end
+
+require 'rest'
+Dir[File.dirname(__FILE__) + '/fixtures/**/*.rb'].each {|file| require file }
+
+ENV['RACK_ENV'] = 'test'
+
+module RSpecMixin
+  include Rack::Test::Methods
+  def app() Rest::Test::TestApplication end
+end
+
+RSpec.configure do |conf|
+  conf.include RSpecMixin
+end

metadata

@@ -0,0 +1,220 @@
+--- !ruby/object:Gem::Specification
+name: sinatra-rest-base
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- bmills
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: thin
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.1'
+- !ruby/object:Gem::Dependency
+  name: builder
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+description: Base class for quickly setting up RESTful services through Sinatra.
+email:
+- brandon.mills@careerbuilder.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/rest.rb
+- lib/rest/application.rb
+- lib/rest/application_helper.rb
+- lib/rest/authentication.rb
+- lib/rest/authentication/authentication_base.rb
+- lib/rest/authentication/basic_authentication.rb
+- lib/rest/error_handeling.rb
+- lib/rest/error_status_handeling.rb
+- lib/rest/exceptions.rb
+- lib/rest/exceptions/invalid_request.rb
+- lib/rest/version.rb
+- sinatra-rest-base.gemspec
+- spec/fixtures/test_application.rb
+- spec/fixtures/test_end_points.rb
+- spec/fixtures/test_errors_end_points.rb
+- spec/lib/rest/application_spec.rb
+- spec/lib/rest/authentication/authentication_base_spec.rb
+- spec/lib/rest/authentication/basic_authentication_spec.rb
+- spec/lib/rest/error_handeling_spec.rb
+- spec/lib/rest/error_status_handeling_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.4
+signing_key: 
+specification_version: 4
+summary: Base class for quickly setting up RESTful services through Sinatra.
+test_files:
+- spec/fixtures/test_application.rb
+- spec/fixtures/test_end_points.rb
+- spec/fixtures/test_errors_end_points.rb
+- spec/lib/rest/application_spec.rb
+- spec/lib/rest/authentication/authentication_base_spec.rb
+- spec/lib/rest/authentication/basic_authentication_spec.rb
+- spec/lib/rest/error_handeling_spec.rb
+- spec/lib/rest/error_status_handeling_spec.rb
+- spec/spec_helper.rb
+has_rdoc: