sonar 0.2.1

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - jruby-19mode
+  - rbx-19mode

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/LICENSE

@@ -0,0 +1,19 @@
+
+Copyright (c) 2012-2013 Walter Smith <waltee.smith@gmail.com>
+
+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,283 @@
+
+<a href="https://travis-ci.org/waltee/sonar">
+<img src="https://travis-ci.org/waltee/sonar.png" align="right"></a>
+
+# Sonar
+
+**API for Testing Rack Apps with easy**
+
+## Install
+
+```bash
+$ [sudo] gem install sonar
+```
+
+## Load
+
+```ruby
+require 'sonar'
+```
+
+## Use
+
+Simply `include Sonar` in your tests.
+
+Or use it directly, by initialize a session via `SonarSession.new`
+
+## App
+
+When mixin used, call `app RackApp` inside testing suite to set app to be tested.
+
+**Minitest Example:**
+
+```ruby
+require 'sonar'
+
+class MyTests < MiniTest::Unit::TestCase
+
+    include Sonar
+
+    def setup
+        app MyRackApp
+    end
+
+    def test
+        get '/url'
+        assert_equal last_response.status, 200
+    end
+end
+```
+
+**[Specular](https://github.com/waltee/specular) Example:**
+
+```ruby
+Spec.new do
+    app MyRackApp
+
+    get '/url'
+    expect(last_response.status) == 200
+end
+```
+
+Multiple apps can be tested within same suite.<br/>
+Each app will run own session.
+
+**Minitest Example:**
+
+```ruby
+require 'sonar'
+
+class MyTests < MiniTest::Unit::TestCase
+
+    include Sonar
+
+    def setup
+        app MyRackApp
+    end
+
+    def test
+        # querying default app
+        get '/url'
+        assert_equal last_response.status, 200
+
+        # testing ForumApp
+        app ForumApp
+        get '/posts'
+        assert_equal last_response.status, 200
+
+        # back to default app
+        app MyRackApp
+        get '/url'
+        assert_equal last_response.status, 200
+    end
+end
+```
+
+When using session manually, you should set app at initialization.
+
+**Example:**
+
+```ruby
+session = SonarSession.new MyRackApp
+session.get '/url'
+assert_equal session.last_response.status, 200
+```
+
+
+## Resetting App
+
+Sometimes you need to start over with a new app in pristine state, i.e. no cookies, no headers etc.
+
+To achieve this, simply call `reset_app!` (or `reset_browser!`).
+
+This will reset currently tested app. Other tested apps will stay untouched.
+
+When creating sessions manually, app can NOT be switched/reset.<br/>
+To test another app, simply create another session.
+
+## Requests
+
+Use one of `get`, `post`, `put`, `patch`, `delete`, `options`, `head`
+to make requests via Sonar browser.
+
+To make a secure request, add `s_` prefix:
+
+```ruby
+s_get  '/path'
+s_post '/path'
+# etc.
+```
+
+To make a request via XHR, aka Ajax, add `_x` suffix:
+
+```ruby
+get_x  '/path'
+post_x '/path'
+# etc.
+```
+
+To make a secure request via XHR, add both `s_` and `_x`:
+
+```ruby
+s_get_x  '/path'
+s_post_x '/path'
+# etc.
+```
+
+In terms of arguments, making HTTP requests via Sonar is identical to calling regular Ruby methods.<br/>
+That's it, you do not need to join parameters into a string.<br/>
+Just pass them as usual arguments:
+
+```ruby
+post '/news', :create, :title => rand
+post '/news', :update, id, :title => rand
+get  '/news', :delete, id
+```
+
+## Map
+
+Previous example works just fine, however it is redundant and inconsistent.<br/>
+Just imagine that tested app changed its base URL from /news to /headlines.
+
+The solution is simple.<br/>
+Use `map` to define a base URL that will be prepended to each request,<br/>
+except ones starting with a slash or a protocol(http://, https:// etc.) of course.
+
+```ruby
+Spec.new do
+    app MyRackApp
+    map '/news'
+
+    post :create, :title => rand
+    post :update, id, :title => rand
+    get  :delete, id
+end
+```
+
+**Note:** requests starting with a slash or protocol(http://, https:// etc.)
+wont use base URL defined by `map`.<br/>
+
+**Note:** when you switching tested app, make sure you also change the map.
+
+To disable mapping, simply call `map nil`
+
+## Cookies
+
+**Set cookies:**
+
+```ruby
+cookies['name'] = 'value'
+```
+
+**Read cookies:**
+
+```ruby
+cookie = cookies['name']
+```
+
+**Delete a cookie:**
+
+```ruby
+cookies.delete 'name'
+```
+
+
+**Clear all cookies:**
+
+```ruby
+cookies.clear
+```
+
+Each app uses its own cookies jar.
+
+## Headers
+
+Sonar allow to set headers that will be sent to app on all consequent requests.
+
+**Set headers:**
+
+```ruby
+header['User-Agent']   = 'Sonar'
+header['Content-Type'] = 'text/plain'
+header['rack.input']   = 'someString'
+# etc.
+```
+
+**Read headers:**
+
+```ruby
+header = headers['User-Agent']
+# etc.
+```
+
+**Delete a header:**
+
+```ruby
+headers.delete 'User-Agent'
+```
+
+**Clear all headers:**
+
+```ruby
+headers.clear
+```
+
+Each app uses its own headers.
+
+## Authorization
+
+**Basic Auth:**
+
+```ruby
+authorize 'user', 'pass'
+```
+
+**Reset earlier set Basic authorization header:**
+
+```ruby
+reset_basic_auth!
+```
+
+**Digest Auth:**
+
+```ruby
+digest_authorize 'user', 'pass'
+```
+
+**Reset earlier set Digest authorization header:**
+
+```ruby
+reset_digest_auth!
+```
+
+**Reset ANY earlier set authorization header:**
+
+```ruby
+reset_auth!
+```
+
+## Follow Redirects
+
+By default, Sonar wont follow redirects.
+
+If last response is a redirect and you want Sonar to follow it, use `follow_redirect!`

data/Rakefile

@@ -0,0 +1,27 @@
+require 'rubygems'
+require 'rake'
+require 'bundler/gem_helper'
+
+task default: :test
+
+require './test/setup'
+
+desc 'Run all tests'
+task :test do
+  ::Dir['./test/test__*.rb'].each { |f| require f }
+  session = Specular.new
+  session.boot { include Sonar }
+  session.before do |app|
+    if app && app.respond_to?(:base_url)
+      app(app)
+      map(app.base_url)
+      get
+    end
+  end
+  session.run /SonarTest/, trace: true
+  puts session.failures if session.failed?
+  puts session.summary
+  session.exit_code
+end
+
+Bundler::GemHelper.install_tasks

data/lib/sonar.rb

@@ -0,0 +1,97 @@
+require 'rubygems'
+require 'uri'
+require 'rack'
+
+
+module SonarConstants
+
+  REQUEST_METHODS = %w[GET POST PUT PATCH DELETE OPTIONS HEAD TRACE].freeze
+  SESSION_METHODS = %w[
+    header headers cookies last_request last_response
+    auth authorize basic_authorize digest_auth digest_authorize
+    reset_auth! reset_basic_auth! reset_digest_auth!
+  ].freeze
+  DEFAULT_HOST = 'sonar.org'.freeze
+  DEFAULT_ENV = {'REMOTE_ADDR' => '127.0.0.1', 'HTTP_HOST' => DEFAULT_HOST}.freeze
+end
+
+module Sonar
+
+  # switch session
+  #
+  # sonar using app based sessions, that's it, creates sessions based on app __id__.
+  # you can test multiple apps and use `app RackApp` to switch between them.
+  #
+  def app app = nil
+    @__sonar__app__ = app if app
+    @__sonar__app__
+  end
+
+  def map *args
+    @__sonar__base_url__ = args.first if args.size > 0
+    @__sonar__base_url__
+  end
+
+  # reset session for current app.
+  # everything will be reset - cookies, headers, authorizations etc.
+  def reset_app!
+    __sonar__session__ :reset
+  end
+
+  alias reset_browser! reset_app!
+
+  ::SonarConstants::REQUEST_METHODS.each do |request_method|
+    define_method request_method.downcase do |*args|
+      params = args.last.is_a?(Hash) ? args.pop : {}
+      request :http, request_method, args.compact.join('/'), params
+    end
+    # secure
+    define_method 's_%s' % request_method.downcase do |*args|
+      params = args.last.is_a?(Hash) ? args.pop : {}
+      request :https, request_method, args.compact.join('/'), params
+    end
+    # xhr
+    define_method '%s_x' % request_method.downcase do |*args|
+      params = args.last.is_a?(Hash) ? args.pop : {}
+      request :http, request_method, args.compact.join('/'), params, {'HTTP_X_REQUESTED_WITH' => 'XMLHttpRequest'}
+    end
+    # secure xhr
+    define_method 's_%s_x' % request_method.downcase do |*args|
+      params = args.last.is_a?(Hash) ? args.pop : {}
+      request :https, request_method, args.compact.join('/'), params, {'HTTP_X_REQUESTED_WITH' => 'XMLHttpRequest'}
+    end
+  end
+
+  ::SonarConstants::SESSION_METHODS.each do |m|
+    define_method m do |*args|
+      __sonar__session__.send m, *args
+    end
+  end
+
+  def request scheme, request_method, uri, params, env = {}
+    uri = [@__sonar__base_url__, uri].compact.join('/') unless uri =~ /\A\/|\A[\w|\d]+\:\/\//
+    uri = ::URI.parse(uri.gsub(/\A\/+/, '/'))
+    uri.scheme ||= scheme.to_s
+    uri.host ||= ::SonarConstants::DEFAULT_HOST
+    uri.path = '/' << uri.path unless uri.path =~ /\A\//
+    params.is_a?(Hash) && params.each_pair do |k, v|
+      (v.is_a?(Numeric) || v.is_a?(Symbol)) && params.update(k => v.to_s)
+    end
+    __sonar__session__.invoke_request request_method, uri, params, env
+  end
+
+  def follow_redirect!
+    last_response.redirect? ||
+        raise('Last response is not an redirect!')
+    scheme = last_request.env['HTTPS'] == 'on' ? 'https' : 'http'
+    request scheme, 'GET', last_response['Location'], {}, {'HTTP_REFERER' => last_request.url}
+  end
+
+  def __sonar__session__ reset = false
+    (@__sonar__session__ ||= {})[app.__id__] = ::SonarSession.new(app) if reset
+    (@__sonar__session__ ||= {})[app.__id__] ||= ::SonarSession.new(app)
+  end
+end
+
+require 'sonar/cookies'
+require 'sonar/session'

data/lib/sonar/cookies.rb

@@ -0,0 +1,125 @@
+class SonarCookies
+  include ::Rack::Utils
+
+  def initialize
+    @jar = {}
+  end
+
+  def jar uri, cookies = nil
+    host = (((uri && uri.host) || ::SonarConstants::DEFAULT_HOST).split('.')[-2..-1]||[]).join('.').downcase
+    @jar[host] = cookies if cookies
+    @jar[host] ||= []
+  end
+
+  def [] name
+    cookies = to_hash
+    cookies[name] && cookies[name].value
+  end
+
+  def []= name, value
+    persist '%s=%s' % [name, ::Rack::Utils.escape(value)]
+  end
+
+  def delete name
+    jar nil, jar(nil).reject { |c| c.name == name }
+  end
+
+  def clear
+    jar nil, []
+  end
+
+  %w[size empty?].each do |m|
+    define_method m do |*args|
+      jar(nil).send __method__, *args
+    end
+  end
+
+  def persist raw_cookies, uri = nil
+    return unless raw_cookies.is_a?(String)
+
+    # before adding new cookies, lets cleanup expired ones
+    jar uri, jar(uri).reject { |c| c.expired? }
+
+    raw_cookies = raw_cookies.strip.split("\n").reject { |c| c.empty? }
+
+    raw_cookies.each do |raw_cookie|
+      cookie = Cookie.new(raw_cookie, uri)
+      cookie.valid?(uri) || next
+      jar(uri, jar(uri).reject { |existing_cookie| cookie.replaces? existing_cookie })
+      jar(uri) << cookie
+    end
+    jar(uri).sort!
+  end
+
+  def to_s uri = nil
+    to_hash(uri).values.map { |c| c.raw }.join(';')
+  end
+
+  def to_hash uri = nil
+    jar(uri).inject({}) do |cookies, cookie|
+      cookies.merge((uri ? cookie.dispose_for?(uri) : true) ? {cookie.name => cookie} : {})
+    end
+  end
+
+  class Cookie
+    include ::Rack::Utils
+
+    attr_reader :raw, :name, :value, :domain, :path, :expires, :default_host
+
+    def initialize raw, uri
+      @default_host = ::SonarConstants::DEFAULT_HOST
+
+      uri ||= default_uri
+      uri.host ||= default_host
+
+      @raw, @options = raw.split(/[;,] */n, 2)
+      @name, @value = parse_query(@raw, ';').to_a.first
+      @options = parse_query(@options, ';')
+
+      @domain = @options['domain'] || uri.host || default_host
+      @domain = '.' << @domain unless @domain =~ /\A\./
+
+      @path = @options['path'] || uri.path.sub(/\/[^\/]*\Z/, '')
+
+      (expires = @options['expires']) && (@expires = ::Time.parse(expires))
+    end
+
+    def replaces? cookie
+      [name.downcase, domain, path] == [cookie.name.downcase, cookie.domain, cookie.path]
+    end
+
+    def empty?
+      value.nil? || value.empty?
+    end
+
+    def secure?
+      @options.has_key?('secure')
+    end
+
+    def expired?
+      expires && expires < ::Time.now.gmtime
+    end
+
+    def dispose_for? uri
+      expired? ? false : valid?(uri)
+    end
+
+    def valid? uri = nil
+      uri ||= default_uri
+      uri.host ||= default_host
+
+      (secure? ? uri.scheme == 'https' : true) &&
+          (uri.host =~ /#{::Regexp.escape(domain.sub(/\A\./, ''))}\Z/i) &&
+          (uri.path =~ /\A#{::Regexp.escape(path)}/)
+    end
+
+    def <=> cookie
+      [name, path, domain.reverse] <=> [cookie.name, cookie.path, cookie.domain.reverse]
+    end
+
+    private
+    def default_uri
+      ::URI.parse('//' << default_host << '/')
+    end
+  end
+end