wd_sinatra 0.0.1

data/lib/wd_sinatra/test_helpers.rb

@@ -0,0 +1,204 @@
+ENV['RACK_ENV'] ||= 'test'
+require 'test/unit'
+require 'rack'
+require 'rack/test'
+require 'json'
+require 'json_response_verification'
+require File.join(File.dirname(__FILE__), '..', 'lib', 'bootloader')
+
+require 'minitest/autorun'
+
+ENV['NO_PRINT_ROUTES'] = 'true'
+Bootloader.start
+WeaselDiesel.send(:include, JSONResponseVerification)
+
+ActiveRecord::Base.logger = nil
+
+class Requester
+  include ::Rack::Test::Methods
+
+  def app
+    Sinatra::Application
+  end
+end
+
+module TestApi
+  module_function
+
+  URL_PLACEHOLDER   = /\/*(:[a-z A-Z _]+)\/*/
+  INTERNAL_X_HEADER = AuthHelpers::INTERNAL_X_HEADER[/HTTP_(.*)/, 1] # strip the header marker added by Rack
+  MOBILE_X_HEADER   = AuthHelpers::MOBILE_X_HEADER[/HTTP_(.*)/, 1]   # strip the header marker added by Rack
+
+  def request(verb, uri, params={}, headers=nil)
+    params ||= {}
+    service_uri = uri.dup
+    matching = uri.scan URL_PLACEHOLDER
+    unless matching.empty?
+      # replace the placeholder by real value
+      matching.flatten.each_with_index do |str, idx|
+        key = str.delete(":").to_sym
+        value = params[key].to_s
+        # delete the value from the params
+        params.delete(key)
+        uri = uri.gsub(str, value)
+        end
+    end
+    
+    request = Requester.new
+    yield request if block_given?
+    headers.each {|name, value| request.header(name, value) } if headers
+    response = request.send(verb, uri, params)
+    @json_response = JsonWrapperResponse.new(response, :verb => verb, :uri => service_uri)
+  end
+
+  def mobile_account=(account)
+    @account = account
+  end
+
+  def get(uri, params=nil, headers=nil)
+    request(:get, uri, params, headers)
+  end
+
+  def internal_get(uri, params=nil, headers=nil)
+    get(uri, params, valid_internal_api_headers(headers))
+  end
+
+  def mobile_get(uri, params=nil, headers=nil)
+    request(:get, uri, params, mobile_headers(headers))
+  end
+
+  def post(uri, params=nil, headers=nil)
+    request(:post, uri, params, headers)
+  end
+
+  def internal_post(uri, params=nil, headers=nil)
+    post(uri, params, valid_internal_api_headers(headers))
+  end
+
+  def mobile_post(uri, params=nil, headers=nil)
+    request(:post, uri, params, mobile_headers(headers))
+  end
+
+  def put(uri, params=nil, headers=nil)
+    request(:put, uri, params, headers)
+  end
+
+  def internal_put(uri, params=nil, headers=nil)
+    put(uri, params, valid_internal_api_headers(headers))
+  end
+
+  def mobile_put(uri, params=nil, headers=nil)
+    request(:put, uri, params, mobile_headers(headers))
+  end
+
+  def delete(uri, params=nil, headers=nil)
+    request(:delete, uri, params, headers)
+  end
+
+  def internal_delete(uri, params=nil, headers=nil)
+    delete(uri, params, valid_internal_api_headers(headers))
+  end
+
+  def mobile_delete(uri, params=nil, headers=nil)
+    request(:delete, uri, params, mobile_headers(headers))
+  end
+
+  def head(uri, params=nil, headers=nil)
+    request(:head, uri, params, headers)
+  end
+
+  def internal_head(uri, params=nil, headers=nil)
+    head(uri, params, valid_internal_api_headers(headers))
+  end
+
+  def mobile_head(uri, params=nil, headers=nil)
+    request(:head, uri, params, mobile_headers(headers))
+  end
+
+  def json_response
+    @json_response
+  end
+
+  def last_response
+    @json_response.rest_response if @json_response
+  end
+
+  def valid_internal_api_headers(headers)
+    custom_headers = {INTERNAL_X_HEADER => AuthHelpers::ALLOWED_API_KEYS[0]}
+    custom_headers.merge!(headers) if headers
+    custom_headers
+  end
+
+  def mobile_headers(headers)
+    custom_headers = {MOBILE_X_HEADER => @account ? Base64.urlsafe_encode64(@account.mobile_token) : nil}
+    custom_headers.merge!(headers) if headers
+    custom_headers
+  end
+
+end
+
+
+# Wrapper around a rest response
+class JsonWrapperResponse
+  extend Forwardable
+
+  attr_reader :rest_response
+  attr_reader :verb
+  attr_reader :uri
+
+  def initialize(response, opts={})
+    @rest_response = response
+    @verb = opts[:verb]
+    @uri = opts[:uri]
+  end
+
+  def body
+    @body ||= JSON.load(rest_response.body) rescue rest_response.body
+  end
+
+  def success?
+    @rest_response.status == 200
+  end
+  
+  def redirected?
+    @rest_response.status.to_s =~ /30\d/
+  end
+
+  def [](val)
+    if body
+      body[val.to_s]
+    else
+      nil
+    end
+  end
+
+  def method_missing(meth, *args)
+    body.send(meth, args)
+  end
+
+  def_delegators :rest_response, :code, :headers, :raw_headers, :cookies, :status, :errors
+end
+
+
+# Custom assertions
+def assert_api_response(response=nil, message=nil)
+  response ||= TestApi.json_response
+  print response.rest_response.errors if response.status === 500
+  assert response.success?, message || ["Body: #{response.rest_response.body}", "Errors: #{response.errors}", "Status code: #{response.status}"].join("\n")
+  service = WSList.all.find{|s| s.verb == response.verb && s.url == response.uri[1..-1]}
+  raise "Service for (#{response.verb.upcase} #{response.uri[1..-1]}) not found" unless service
+  unless service.response.nodes.empty?
+    assert response.body.is_a?(Hash), "Invalid JSON response:\n#{response.body}"
+    valid, errors = service.validate_hash_response(response.body)
+    assert valid, errors.join(" & ") || message
+  end
+end
+
+def assert_api_response_with_redirection(redirection_url=nil)
+  response = TestApi.json_response
+  print response.rest_response.errors if response.status === 500
+  assert response.status == 302, "Redirection expect, but got #{response.status}"
+  if redirection_url
+    assert response.headers["location"], redirection_url
+  end
+end

data/lib/wd_sinatra/version.rb

@@ -0,0 +1,5 @@
+module WD
+  module Sinatra
+    VERSION = "0.0.1"
+  end
+end

data/templates/Gemfile

@@ -0,0 +1,23 @@
+source "http://rubygems.org"
+
+# web engine
+gem "sinatra", "1.3.2"
+# service DSL
+gem "weasel_diesel"
+gem "wd_sinatra"
+
+
+if RUBY_VERSION =~ /1.8/
+  gem 'backports', '2.3.0'
+  gem 'json'
+end
+
+if ENV['RACK_ENV'] != "production"
+  gem "rack-test", "0.6.1"
+  # gem "foreman"
+  # gem "puma"
+  gem "minitest"
+  # gem "guard-puma"
+  # gem "guard-minitest"
+  gem "rake"
+end

data/templates/Guardfile

@@ -0,0 +1,13 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'puma' do
+  watch('Gemfile.lock')
+  watch(%r{^config|lib/.*})
+end
+
+guard 'minitest', :test_file_patterns => '*_test.rb' do
+  watch(%r|^test/(.*)_test\.rb|)
+  watch(%r{^api/(.*/)?([^/]+)\.rb$})  { |m| "test/api/#{m[1]}#{m[2]}_test.rb" }
+  watch(%r|^test/test_helper\.rb|)    { "test" }
+end

data/templates/Rakefile

@@ -0,0 +1,32 @@
+require 'rbconfig'
+require 'rake/testtask'
+require 'rubygems'
+require 'bundler'
+Bundler.setup
+require 'wd_sinatra/app_loader'
+
+root = File.expand_path(File.dirname(__FILE__))
+
+Rake::TestTask.new do |t|
+  t.libs << "."
+  t.libs << 'test'
+  t.pattern = "test/**/*_test.rb"
+end
+
+task :default => :test
+
+# boot the app
+task :setup_app do
+  ENV['DONT_CONNECT'] = 'true'
+  WDSinatra::AppLoader.server(root)
+end
+
+task :environment do
+  ENV['DONT_CONNECT'] = nil
+  WDSinatra::AppLoader.server(root)
+end
+
+WDSinatra::AppLoader.set_loadpath(root)
+Dir.glob("lib/tasks/**/*.rake").each do |task_file|
+  load task_file
+end

data/templates/api/hello_world.rb

@@ -0,0 +1,29 @@
+describe_service "hello_world" do |service|
+  service.formats   :json
+  service.http_verb :get
+  service.disable_auth # on by default
+
+  # INPUT
+  service.param.string  :name, :default => 'World'
+
+  # OUTPUT
+  service.response do |response|
+    response.object do |obj|
+      obj.string :message, :doc => "The greeting message sent back. Defaults to 'World'"
+      obj.datetime :at, :doc => "The timestamp of when the message was dispatched"
+    end
+  end
+
+  # DOCUMENTATION
+  service.documentation do |doc|
+    doc.overall "This service provides a simple hello world implementation example."
+    doc.param :name, "The name of the person to greet."
+    doc.example "<code>curl -I 'http://localhost:9292/hello_world?name=Matt'</code>"
+  end
+
+  # ACTION/IMPLEMENTATION
+  service.implementation do
+    {:message => "Hello #{params[:name]}", :at => Time.now}.to_json
+  end
+
+end

data/templates/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+require 'irb'
+require 'rubygems'
+require 'wd_sinatra/app_loader'
+root = File.expand_path('..', File.dirname(__FILE__))
+WDSinatra::AppLoader.console(root)
+IRB.start(__FILE__)

data/templates/config.ru

@@ -0,0 +1,5 @@
+require 'rubygems'
+require 'wd_sinatra/app_loader'
+root = File.expand_path(File.dirname(__FILE__))
+WDSinatra::AppLoader.server(root)
+run Sinatra::Application

data/templates/config/app.rb

@@ -0,0 +1,5 @@
+# called after the environment is setup and the basic dependencies are loaded
+# but before the models are loaded.
+#
+# Here you want to load your dependencies and maybe set your
+# datastore.

data/templates/config/environments/default.rb

@@ -0,0 +1,3 @@
+# This is the default environment setup.
+# It can be overwritten or extended by a custom environment file.
+# Note: the LOGGER constant isn't yet defined and shouldn't be defined here.

data/templates/config/environments/production.rb

@@ -0,0 +1,2 @@
+require 'logger'
+LOGGER.level = Logger::INFO

data/templates/config/environments/test.rb

@@ -0,0 +1,3 @@
+require 'logger'
+LOGGER = Logger.new($stdout)
+LOGGER.level = Logger::FATAL

data/templates/config/hooks.rb

@@ -0,0 +1,74 @@
+require 'body_parser' # from the lib folder
+# Change the JSON parser if you want to use Yajl for instance.
+require 'json'
+BodyParser.json_parser = JSON
+
+module WDSinatraHooks
+
+  MOBILE_X_HEADER   = 'HTTP_X_MOBILE_TOKEN'
+  INTERNAL_X_HEADER = 'HTTP_X_INTERNAL_API_KEY'
+  JSON_BODY_VERBS   =  %w(POST PUT DELETE)
+
+  ####### HOOKS #############################
+  #
+  # This hook gets called before the params
+  # are being verified. It's a good place to add a content type
+  # handler for instance like shown below.
+  # If you don't need this hook, just delete it.
+  # Note that you have access to the request context, see sinatra_ext.rb
+  # in the wd_sinatra repository to see how this is implemented.
+  #
+  # @param [Hash] params the incoming params.
+  # processed.
+  # @returns [Hash] the pre processed params.
+  def params_preprocessor_hook(params)
+    if JSON_BODY_VERBS.include?(request.request_method)
+      BodyParser.parse(params, request.body, request.content_type)
+    else
+      params
+    end
+  end
+
+  # This hook gets called after the params are being verified.
+  # You can use this hook to modify the params before sending them to
+  # your service.
+  #
+  # @param [Hash] params the incoming params.
+  # processed.
+  # @returns [Hash] the post processed params.
+  # def params_postprocessor_hook(params)
+  # end
+
+  # This hook gets called before dispatching any
+  # requests.
+  # 
+  # Implementation example
+  def pre_dispatch_hook
+    if service.extra[:mobile]
+      mobile_auth_check
+    elsif service.extra[:internal]
+      internal_api_key_check
+    elsif !service.auth_required
+      return
+    else
+      halt 403 # protect by default
+    end
+  end
+  #
+  #########################################
+
+  # AUTHENTICATION
+
+  # Implementation example
+  def mobile_auth_check
+    true
+  end
+
+  # Implementation example
+  def internal_api_key_check
+    true
+  end
+
+end
+
+Sinatra::Helpers.send(:include, WDSinatraHooks)

data/templates/config/sinatra_config.rb

@@ -0,0 +1,12 @@
+set :environment, RACK_ENV
+set :root, WDSinata.root_path
+set :app_file, __FILE__
+set :public_folder, File.join(WDSinata.root_path, "public")
+# Checks on static files before dispatching calls
+enable :static
+# enable rack session
+enable :session
+set :raise_errors, false
+# enable that option to run by calling this file automatically (without using the config.ru file)
+# enable :run
+use Rack::ContentLength

data/templates/lib/body_parser.rb

@@ -0,0 +1,24 @@
+module BodyParser
+  module_function
+
+  JSON_TYPE = "application/json"
+
+  # Parses the body
+  def parse(params, body, content_type)
+    case content_type
+    when JSON_TYPE 
+      params.merge(json_parser.parse(body.string))
+    else
+      params
+    end
+  end
+
+  def json_parser=(parser_klass)
+    @json_parser = parser_klass
+  end
+
+  def json_parser
+    @json_parser
+  end
+  
+end