sonar 0.2.1

data/lib/sonar/session.rb

@@ -0,0 +1,150 @@
+class SonarSession
+
+  include ::Sonar
+
+  attr_reader :headers, :cookies, :last_request, :last_response
+  alias header headers
+
+  def initialize app
+    app.respond_to?(:call) ||
+        raise('app should be a valid Rack app')
+
+    @app = app
+    @headers, @cookies = {}, ::SonarCookies.new
+  end
+
+  def basic_authorize user, pass
+    @basic_auth = [user, pass]
+  end
+
+  alias authorize basic_authorize
+  alias auth basic_authorize
+
+  def digest_authorize user, pass
+    @digest_auth = [user, pass]
+  end
+
+  alias digest_auth digest_authorize
+
+  def reset_basic_auth!
+    @basic_auth = nil
+  end
+
+  def reset_digest_auth!
+    @digest_auth = nil
+  end
+
+  def reset_auth!
+    reset_basic_auth!
+    reset_digest_auth!
+  end
+
+  def invoke_request request_method, uri, params, env
+
+    default_env = ::SonarConstants::DEFAULT_ENV.dup.merge(env)
+    default_env.update :method => request_method
+    default_env.update :params => params
+    default_env.update 'HTTP_COOKIE' => cookies.to_s(uri)
+    default_env.update basic_auth_header
+
+    process_request uri, default_env
+
+    if @digest_auth && @last_response.status == 401 && (challenge = @last_response['WWW-Authenticate'])
+      default_env.update digest_auth_header(challenge, uri.path, request_method)
+      process_request uri, default_env
+    end
+
+    cookies.persist(@last_response.header['Set-Cookie'], uri)
+
+    @last_response.respond_to?(:finish) && @last_response.finish
+    @last_response
+  end
+
+  def __sonar__session__
+    self
+  end
+
+  def reset_app!
+    raise 'It makes no sense to use `%s` with manually created sessions. To test another app, just create a new session.' % __method__
+  end
+
+  alias reset_browser! reset_app!
+
+  def app *args
+    args.any? && raise('It makes no sense to use `%s` with manually created sessions. To test another app, just create a new session.' % __method__)
+    @app
+  end
+
+  private
+  def process_request uri, env
+    env = ::Rack::MockRequest.env_for(uri.to_s, env.dup)
+    explicit_env = headers_to_env
+    explicit_env['rack.input'] &&
+        env['REQUEST_METHOD'] == 'POST' && env.delete('CONTENT_TYPE')
+    env.update explicit_env
+
+    @last_request = ::Rack::Request.new(env)
+
+    # initializing params. do not remove! needed for nested params to work
+    @last_request.params
+
+    status, headers, body = app.call(@last_request.env)
+
+    @last_response = ::Rack::MockResponse.new(status, headers, body, env['rack.errors'].flush)
+    body.respond_to?(:close) && body.close
+  end
+
+  def headers_to_env
+    headers.keys.inject({}) do |headers, key|
+      value = headers()[key]
+      if (key =~ /\A[[:upper:]].*\-?[[:upper:]]?.*?/) && (key !~ /\AHTTP_|\ACONTENT_TYPE\Z/)
+        key = (key == 'Content-Type' ? '' : 'HTTP_') << key.upcase.gsub('-', '_')
+      end
+      headers.merge key => value
+    end
+  end
+
+  def basic_auth_header
+    (auth = @basic_auth) ?
+        {'HTTP_AUTHORIZATION' => 'Basic %s' % ["#{auth.first}:#{auth.last}"].pack("m*")} :
+        {}
+  end
+
+  def digest_auth_header challenge, uri, request_method
+    params = ::Rack::Auth::Digest::Params.parse(challenge.split(" ", 2).last)
+    params.merge!({
+                      "username" => @digest_auth.first,
+                      "nc" => "00000001",
+                      "cnonce" => "nonsensenonce",
+                      "uri" => uri,
+                      "method" => request_method,
+                  })
+    params["response"] = MockDigestRequest.new(params).response(@digest_auth.last)
+    {'HTTP_AUTHORIZATION' => 'Digest ' << params.map {|p| '%s="%s"' % p}.join(', ')}
+  end
+
+  class MockDigestRequest # stolen from rack-test
+
+    def initialize(params)
+      @params = params
+    end
+
+    def method_missing(sym)
+      if @params.has_key? k = sym.to_s
+        return @params[k]
+      end
+
+      super
+    end
+
+    def method
+      @params['method']
+    end
+
+    def response(password)
+      Rack::Auth::Digest::MD5.new(nil).send :digest, self, password
+    end
+
+  end
+
+end

data/sonar.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+
+version = '0.2.1'
+Gem::Specification.new do |s|
+
+  s.name = 'sonar'
+  s.version = version
+  s.authors = ['Walter Smith', 'Joran Kikke']
+  s.email = ['waltee.smith@gmail.com', 'joran.k@gmail.com']
+  s.homepage = 'https://github.com/dangerousbeans/sonar'
+  s.summary = 'sonar-%s' % version
+  s.description = 'API for Testing Rack Applications via Mock HTTP'
+
+  s.required_ruby_version = '>= 1.9.2'
+
+  s.add_dependency 'rack', '~> 1.5'
+
+  s.add_development_dependency 'rake', '~> 10'
+  s.add_development_dependency 'specular', '~> 0.2.2'
+  s.add_development_dependency 'bundler'
+
+  s.require_paths = ['lib']
+  s.files = Dir['**/{*,.[a-z]*}'].reject {|e| e =~ /\.(gem|lock)\Z/}
+  s.licenses = ['MIT']
+end

data/test/setup.rb

@@ -0,0 +1,152 @@
+require 'rubygems'
+require 'specular'
+
+$:.unshift ::File.expand_path '../../lib', __FILE__
+require 'sonar'
+
+class Air < ::Rack::Request
+  class << self
+
+    def use ware = nil, *args, &proc
+      @middleware ||= []
+      @middleware << [ware, args, proc] if ware
+      @middleware
+    end
+
+    def map
+      @map
+    end
+
+    def action_map
+      @action_map
+    end
+
+    def app root = nil
+      if root
+        @root = root
+      else
+        return @app if @app
+      end
+      map!
+
+      builder, app = ::Rack::Builder.new, self
+      use.each do |w|
+        ware, args, proc = w
+        builder.use ware, *args, &proc
+      end
+      map.each_key do |route|
+        builder.map route do
+          run lambda { |env| app.new(env).__air__response__ route }
+        end
+      end
+      @app = builder.to_app
+    end
+
+    alias to_app app
+
+    def call env
+      app.call env
+    end
+
+    def base_url
+      @root || '/'
+    end
+
+    alias baseurl base_url
+
+    private
+    def map!
+      @action_map = {}
+      @map = self.instance_methods(false).reject { |m| m.to_s =~ /^__air__/ }.inject({}) do |map, meth|
+        route, request_method = meth.to_s, 'GET'
+        SonarConstants::REQUEST_METHODS.each do |rm|
+          regex = /^#{rm}_/i
+          route =~ regex && (route = route.sub(regex, '')) && (request_method = rm.upcase) && break
+        end
+
+        {'____' => '.',
+         '___' => '-',
+         '__' => '/'}.each_pair { |f, t| route = route.gsub(f, t) }
+
+        arity = self.instance_method(meth).arity
+        setup = [meth, arity < 0 ? -arity - 1 : arity]
+        (map[rootify(route)] ||={})[request_method] = setup
+        (map[rootify] ||= {})[request_method] = setup if route == 'index'
+        @action_map[meth.to_sym] = rootify(route)
+        map
+      end
+    end
+
+    def rootify route = nil
+      ('/%s/%s' % [base_url, route]).gsub /\/+/, '/'
+    end
+  end
+
+  attr_reader :response
+
+  def __air__response__ route
+    rsp = catch :__air__halt__ do
+      @response = ::Rack::Response.new
+      rest_map = self.class.map[route] || halt(404)
+      action, required_parameters = rest_map[env['REQUEST_METHOD']] || halt(404)
+      arguments = env['PATH_INFO'].to_s.split('/').select { |c| c.size > 0 }
+      arguments.size == required_parameters || halt(404, '%s arguments expected, %s given' % [required_parameters, arguments.size])
+      response.body = [self.send(action, *arguments).to_s]
+      response
+    end
+    rsp['Content-Type'] ||= 'text/html'
+    rsp.finish
+  end
+
+  def base_url
+    self.class.base_url
+  end
+
+  def halt status, message = nil
+    response.status = status
+    response.body = [message] if message
+    throw :__air__halt__, response
+  end
+
+  def redirect action_or_path
+    response['Location'] = self.class.action_map[action_or_path] || action_or_path
+    response.status = 302
+    throw :__air__halt__, response
+  end
+
+  def permanent_redirect action_or_path
+    response['Location'] = self.class.action_map[action_or_path] || action_or_path
+    response.status = 301
+    throw :__air__halt__, response
+  end
+
+  def params
+    @__air__params__ ||= indifferent_params(super)
+  end
+
+  def get_params
+    @__air__get_params__ ||= indifferent_params(self.GET)
+  end
+
+  def post_params
+    @__air__post_params__ ||= indifferent_params(self.POST)
+  end
+
+  private
+  def indifferent_params(object)
+    case object
+      when Hash
+        new_hash = indifferent_hash
+        object.each { |key, value| new_hash[key] = indifferent_params(value) }
+        new_hash
+      when Array
+        object.map { |item| indifferent_params(item) }
+      else
+        object
+    end
+  end
+
+  def indifferent_hash
+    Hash.new { |hash, key| hash[key.to_s] if Symbol === key }
+  end
+end

data/test/test__app.rb

@@ -0,0 +1,71 @@
+module SonarTest__app
+
+  class App < Air
+
+    def index
+      __method__
+    end
+
+  end
+
+  class JustAnotherApp < Air
+    def another
+      __method__
+    end
+  end
+
+  Spec.new App do
+
+    get
+    expect(last_response.status) == 200
+    expect(last_response.body) == 'index'
+
+    Testing :cookies do
+      cookies['foo'] = 'bar'
+      expect(cookies['foo']) == 'bar'
+    end
+
+    Testing :headers do
+      header['User-Agent'] = 'Sonar'
+      expect(headers['User-Agent']) == 'Sonar'
+    end
+
+
+    When 'switching app' do
+      app JustAnotherApp
+
+      It 'should use own cookies jar' do
+        is(cookies['foo']).nil?
+      end
+
+      And 'own headers' do
+        is(headers['User-Agent']).nil?
+      end
+
+      get
+      expect(last_response.status) == 404
+
+      get :another
+      expect(last_response.status) == 200
+    end
+
+    When 'switching back to default app' do
+      app App
+
+      It 'should have previously cookies set' do
+        expect(cookies['foo']) == 'bar'
+      end
+
+      And :headers do
+        expect(headers['User-Agent']) == 'Sonar'
+      end
+
+      get
+      expect(last_response.status) == 200
+
+      get :another
+      expect(last_response.status) == 404
+    end
+
+  end
+end

data/test/test__auth.rb

@@ -0,0 +1,144 @@
+module SonarTest__auth
+
+  class Basic < Air
+
+    use Rack::Auth::Basic do |u, p|
+      [u, p] == ['user', 'pass']
+    end
+
+    def index
+      __method__
+    end
+
+    def post_index
+      __method__
+    end
+
+  end
+
+  class Digest < Air
+
+    use Rack::Auth::Digest::MD5, 'AccessRestricted', rand.to_s do |u|
+      {'digest-user' => 'digest-pass'}[u]
+    end
+
+    def index
+      __method__
+    end
+
+    def post_index
+      __method__
+    end
+
+  end
+
+  Spec.new self do
+
+    Testing :Basic do
+      app Basic
+
+      r = get
+      expect(r.status) == 401
+
+      auth 'user', 'pass'
+      r = get
+      expect(r.status) == 200
+      expect(r.body) == 'index'
+
+      o 'reset auth using `reset_auth!`'
+      reset_auth!
+
+      r = get
+      expect(r.status) == 401
+
+      o 'relogin'
+      auth 'user', 'pass'
+      r = get
+      expect(r.status) == 200
+      expect(r.body) == 'index'
+
+      o 'reset auth using `reset_basic_auth!`'
+      reset_basic_auth!
+
+      r = get
+      expect(r.status) == 401
+
+      o 'relogin'
+      auth 'user', 'pass'
+      r = get
+      expect(r.status) == 200
+      expect(r.body) == 'index'
+
+      Should 'fail with wrong credentials' do
+        reset_basic_auth!
+
+        auth 'bad', 'guy'
+        r = get
+        expect(r.status) == 401
+      end
+
+      Should 'auth via POST' do
+        reset_basic_auth!
+
+        auth 'user', 'pass'
+        r = post
+        expect(r.status) == 200
+        expect(r.body) == 'post_index'
+      end
+    end
+
+    Testing :Digest do
+      app Digest
+
+      r = get
+      expect(r.status) == 401
+
+      digest_auth 'digest-user', 'digest-pass'
+      r = get
+      expect(r.status) == 200
+      expect(r.body) == 'index'
+
+      o 'reset auth using `reset_auth!`'
+      reset_digest_auth!
+
+      r = get
+      expect(r.status) == 401
+
+      o 'relogin'
+      digest_auth 'digest-user', 'digest-pass'
+      r = get
+      expect(r.status) == 200
+      expect(r.body) == 'index'
+
+      o 'reset auth using `reset_basic_auth!`'
+      reset_digest_auth!
+
+      r = get
+      expect(r.status) == 401
+
+      o 'relogin'
+      digest_auth 'digest-user', 'digest-pass'
+      r = get
+      expect(r.status) == 200
+      expect(r.body) == 'index'
+
+      Should 'fail with wrong credentials' do
+        reset_digest_auth!
+
+        digest_auth 'bad', 'guy'
+        r = get
+        expect(r.status) == 401
+      end
+
+      Should 'auth via POST' do
+        reset_digest_auth!
+
+        digest_auth 'digest-user', 'digest-pass'
+        r = post
+        expect(r.status) == 200
+        expect(r.body) == 'post_index'
+      end
+    end
+
+  end
+end